package dao

import (
	"encoding/json"
	"errors"
	"fmt"
	"github.com/jinzhu/copier"
	"gorm.io/gorm"
	"micro-bundle/internal/model"
	"micro-bundle/pb/bundle"
	"micro-bundle/pkg/app"
	commonErr "micro-bundle/pkg/err"
	"micro-bundle/pkg/msg"
	"micro-bundle/pkg/utils"
	"strconv"
	"time"
)

func CreateOrderRecord(orderRecord *model.BundleOrderRecords) (res *bundle.CommonResponse, err error) {
	res = new(bundle.CommonResponse)
	var bundleInfo model.BundleProfile
	// 查询套餐主表并预加载
	err = app.ModuleClients.BundleDB.Model(&model.BundleProfile{}).
		Where("uuid = ?", orderRecord.BundleUUID).
		Preload("BundleToValueAddService").
		Preload("BundleProfileLang", "language = ?", orderRecord.Language).
		First(&bundleInfo).Error
	if err != nil {
		res.Msg = msg.ErrorBundleNotFound
		return res, commonErr.ReturnError(err, msg.ErrorBundleNotFound, "查询Bundle信息失败: ")
	}
	// 填充BundleCommonJson字段
	if bundleJson, e := json.Marshal(bundleInfo); e == nil {
		orderRecord.BundleCommonJson = bundleJson
	} else {
		res.Msg = msg.ErrorDataConvert
		return res, commonErr.ReturnError(e, msg.ErrorDataConvert, "Bundle信息转换失败: ")
	}
	err = app.ModuleClients.BundleDB.Model(&model.BundleOrderRecords{}).Create(orderRecord).Error
	if err != nil {
		res.Msg = msg.ErrorCreateOrderInfo
		return res, commonErr.ReturnError(err, msg.ErrorCreateOrderInfo, "创建订单信息失败: ")
	}
	res.Uuid = orderRecord.UUID
	res.OrderNo = orderRecord.OrderNo
	res.Msg = msg.SuccessCreateOrderInfo
	return
}

// calculateAmount 计算子订单金额
func calculateAmount(valueUid string, req *bundle.OrderRecord) (amount float64, valueAddServiceLang *model.ValueAddServiceLang, num int32, expirationDay string, err error) {
	err = app.ModuleClients.BundleDB.
		Where("uuid = ? AND language = ?", valueUid, req.Language).
		First(&valueAddServiceLang).Error
	if err != nil {
		return
	}
	for _, opt := range valueAddServiceLang.Options {
		for _, p := range req.PriceOptionsInfo {
			if p.ValueUid == valueUid && opt.Id == p.Id {
				num = opt.Num
				if valueAddServiceLang.PriceMode == 1 {
					amount = float64(float32(opt.Num) * opt.Price)
				} else if valueAddServiceLang.PriceMode == 2 {
					amount = float64(opt.Price)
				}
			}
		}

		// 计算过期时间
		if valueAddServiceLang.ServiceType == 5 {
			expirationDay = calculateExpirationDay(opt.Num, valueAddServiceLang.Unit)
		}
	}
	return
}

// calculateExpirationDay 计算到期日
func calculateExpirationDay(num int32, unit string) string {
	now := time.Now()
	switch unit {
	case "天":
		return now.AddDate(0, 0, int(num)).Format("2006-01-02")
	case "月":
		return now.AddDate(0, int(num), 0).Format("2006-01-02")
	case "年":
		return now.AddDate(int(num), 0, 0).Format("2006-01-02")
	default:
		return ""
	}
}
func UpdateOrderRecord(orderRecord *model.BundleOrderRecords) (res *bundle.CommonResponse, err error) {
	res = new(bundle.CommonResponse)
	err = app.ModuleClients.BundleDB.Model(&model.BundleOrderRecords{}).Where("uuid = ?", orderRecord.UUID).Updates(orderRecord).Error
	if err != nil {
		res.Msg = msg.ErrorUpdateOrderInfo
		return res, commonErr.ReturnError(err, msg.ErrorUpdateOrderInfo, "更新订单信息失败: ")
	}
	res.Uuid = orderRecord.UUID
	res.Msg = msg.SuccessUpdateOrderInfo
	return
}

func UpdateOrderRecordByOrderNO(orderRecord *model.BundleOrderRecords) (res *bundle.CommonResponse, err error) {
	res = new(bundle.CommonResponse)
	// Step 1: 先更新子订单（增值服务）的支付状态
	valueAdd := &model.BundleOrderValueAdd{
		PaymentStatus: int(orderRecord.Status),
		PaymentTime:   orderRecord.PayTime,
	}
	if orderRecord.CheckoutSessionId != "" {
		valueAdd.CheckoutSessionId = orderRecord.CheckoutSessionId
		valueAdd.CheckoutSessionUrl = orderRecord.CheckoutSessionUrl
	}
	err = app.ModuleClients.BundleDB.Model(&model.BundleOrderValueAdd{}).
		Where("order_no = ?", orderRecord.OrderNo).
		Updates(valueAdd).Error
	if err != nil {
		res.Msg = msg.ErrorUpdateOrderInfo
		return res, commonErr.ReturnError(err, msg.ErrorUpdateOrderInfo, "更新增值服务支付状态失败: ")
	}
	// Step 2: 再更新主订单信息（如果存在）
	err = app.ModuleClients.BundleDB.Model(&model.BundleOrderRecords{}).
		Where("order_no = ?", orderRecord.OrderNo).
		Updates(orderRecord).Error
	// Step 3: 返回结果（即使主订单更新失败，也视为成功）
	res.Uuid = orderRecord.UUID
	res.Msg = msg.SuccessUpdateOrderInfo
	return res, nil
}

func OrderRecordsList(req *bundle.OrderRecordsRequest) (res *bundle.OrderRecordsResponse, err error) {
	res = new(bundle.OrderRecordsResponse)
	res.OrderRecords = make([]*bundle.OrderRecord, 0)
	records := make([]*model.BundleOrderRecords, 0)

	query := app.ModuleClients.BundleDB.Model(&model.BundleOrderRecords{})

	query.Joins("left join `micro-account`.`user` on `micro-account`.`user`.`id` = `bundle_order_records`.`customer_id`")

	if req.CustomerID != "" {
		query = query.Where("customer_id = ?", req.CustomerID)
	}

	if req.CustomerNum != "" {
		query = query.Where("customer_num like ?", "%"+req.CustomerNum+"%")
	}

	if req.CustomerName != "" {
		query = query.Where("customer_name like ?", "%"+req.CustomerName+"%")
	}

	if req.BundleName != "" {
		query = query.Where("bundle_name like ?", "%"+req.BundleName+"%")
	}

	if req.BundleUUID != "" {
		query = query.Where("bundle_uuid = ?", req.BundleUUID)
	}

	if req.OrderNo != "" {
		query = query.Where("order_no like ?", "%"+req.OrderNo+"%")
	}

	if req.Status != 0 {
		query = query.Where("`bundle_order_records`.status = ?", req.Status)
	}

	if req.StartSignedTime != "" {
		query = query.Where("signed_time >= ?", req.StartSignedTime)
	}

	if req.EndSignedTime != "" {
		query = query.Where("signed_time <= ?", req.EndSignedTime)
	}

	if req.StartPayTime != "" {
		query = query.Where("pay_time >= ?", req.StartPayTime)
	}

	if req.EndPayTime != "" {
		query = query.Where("pay_time <= ?", req.EndPayTime)
	}

	if req.IsHaveValueAdd == 1 { // 有
		query = query.Where("value_add_bundle_uuid != ?", "")
	} else if req.IsHaveValueAdd == 2 { // 无
		query = query.Where("IFNULL(value_add_bundle_uuid,'') = ''")
	}

	if req.FinancialConfirmation != 0 {
		query = query.Where("financial_confirmation = ?", req.FinancialConfirmation)
	}

	if req.TelNum != "" {
		query = query.Where("`micro-account`.`user`.`tel_num` like ?", "%"+req.TelNum+"%")
	}

	count := *query

	if req.PageSize != 0 && req.Page != 0 {
		query = query.Limit(int(req.PageSize)).Offset(int(req.Page-1) * int(req.PageSize))
	}

	err = query.Find(&records).Error

	if err != nil {
		return res, commonErr.ReturnError(err, msg.ErrorGetOrderList, "获取订单信息失败: ")
	}

	//_ = copier.CopyWithOption(&res.OrderRecords, records, copier.Option{DeepCopy: true})

	for _, record := range records {
		res.OrderRecords = append(res.OrderRecords, &bundle.OrderRecord{
			Uuid:                  record.UUID,
			OrderNo:               record.OrderNo,
			BundleUuid:            record.BundleUUID,
			BundleName:            record.BundleName,
			CustomerID:            record.CustomerID,
			CustomerNum:           record.CustomerNum,
			CustomerName:          record.CustomerName,
			Amount:                record.Amount,
			AmountType:            record.AmountType,
			SignContract:          record.SignContract,
			Signature:             record.Signature,
			SignedTime:            record.SignedTime,
			PayType:               record.PayType,
			PayTime:               record.PayTime,
			CheckoutSessionId:     record.CheckoutSessionId,
			CheckoutSessionUrl:    record.CheckoutSessionUrl,
			Status:                record.Status,
			ContractNo:            record.ContractNo,
			ValueAddBundleUuid:    record.ValueAddBundleUUID,
			ValueAddBundleAmount:  record.ValueAddBundleAmount,
			ValueAddOriginalPrice: record.ValueAddOriginalPrice,
			ValueAddDiscountPrice: record.ValueAddDiscountPrice,
			ValueAddSavedAmount:   record.ValueAddSavedAmount,
			TotalAmount:           record.TotalAmount,
			Num:                   record.Num,
			BundleCommonUid:       record.BundleCommonUid,
			AddBundleCommonUid:    record.AddBundleCommonUid,
			FinancialConfirmation: record.FinancialConfirmation,
			ExpirationTime:        record.ExpirationTime,
		})
	}

	var total int64

	count.Count(&total)

	res.Total = int32(total)

	return
}

func OrderRecordDetail(req *bundle.OrderRecordsDetailRequest) (res *bundle.OrderRecord, err error) {
	res = new(bundle.OrderRecord)
	orderRecord := new(model.BundleOrderRecords)

	query := app.ModuleClients.BundleDB.Model(&model.BundleOrderRecords{})

	if req.Uuid != "" {
		query = query.Where("uuid = ?", req.Uuid)
	}

	if req.OrderNo != "" {
		query = query.Where("order_no = ?", req.OrderNo)
	}

	if req.CustomerID != "" {
		query = query.Where("customer_id = ?", req.CustomerID)
	}
	if req.BundleUUID != "" {
		query = query.Where("bundle_uuid = ?", req.BundleUUID)
	}
	err = query.Order("expiration_time desc").First(&orderRecord).Error
	if err != nil {
		return res, commonErr.ReturnError(err, msg.ErrorGetOrderInfo, "获取订单信息失败: ")
	}
	//_ = copier.CopyWithOption(&res, orderRecord, copier.Option{DeepCopy: true})

	addBundles := make([]model.BundleOrderValueAdd, 0)
	err = app.ModuleClients.BundleDB.Model(model.BundleOrderValueAdd{}).Where("deleted is null and source = 1 and order_no = ?", req.OrderNo).Find(&addBundles).Error
	if err != nil {
		return res, commonErr.ReturnError(err, "增值订单信息", "获取增值订单信息失败: ")
	}
	addInfos := make([]*bundle.AddInfo, 0)
	for _, addBundle := range addBundles {
		addInfo := &bundle.AddInfo{
			OrderNo:      addBundle.OrderNo,
			Num:          addBundle.Num,
			ValueAddUUID: addBundle.ValueAddUUID,
		}
		addInfos = append(addInfos, addInfo)
	}

	res = &bundle.OrderRecord{
		Uuid:                 orderRecord.UUID,
		OrderNo:              orderRecord.OrderNo,
		BundleUuid:           orderRecord.BundleUUID,
		BundleName:           orderRecord.BundleName,
		CustomerID:           orderRecord.CustomerID,
		CustomerNum:          orderRecord.CustomerNum,
		CustomerName:         orderRecord.CustomerName,
		Amount:               orderRecord.Amount,
		AmountType:           orderRecord.AmountType,
		SignContract:         orderRecord.SignContract,
		Signature:            orderRecord.Signature,
		SignedTime:           orderRecord.SignedTime,
		PayType:              orderRecord.PayType,
		PayTime:              orderRecord.PayTime,
		CheckoutSessionId:    orderRecord.CheckoutSessionId,
		CheckoutSessionUrl:   orderRecord.CheckoutSessionUrl,
		Status:               orderRecord.Status,
		ContractNo:           orderRecord.ContractNo,
		ValueAddBundleUuid:   orderRecord.ValueAddBundleUUID,
		ValueAddBundleAmount: orderRecord.ValueAddBundleAmount,
		TotalAmount:          orderRecord.TotalAmount,
		ExpirationTime:       orderRecord.ExpirationTime,
	}
	res.AddInfos = make([]*bundle.AddInfo, 0)
	res.AddInfos = addInfos
	return
}
func PackagePriceAndTime(orderRecord *bundle.OrderRecord) (res *bundle.PackagePriceAndTimeResponse, err error) {
	res = new(bundle.PackagePriceAndTimeResponse)
	bundleInfo := new(model.BundleProfile)
	// 查询套餐主表并预加载
	err = app.ModuleClients.BundleDB.Model(&model.BundleProfile{}).
		Where("uuid = ?", orderRecord.BundleUuid).
		Preload("BundleToValueAddService").
		Preload("BundleProfileLang", "language = ?", orderRecord.Language).
		First(&bundleInfo).Error
	if err != nil {
		return res, commonErr.ReturnError(err, msg.ErrorBundleNotFound, "查询Bundle信息失败: ")
	}
	var (
		valueAddAmount float64
		expirationTime = "9999-12-31"
	)
	for _, service := range bundleInfo.BundleToValueAddService {
		amount, _, _, day, e := calculateAmount(service.ValueUid, orderRecord)
		if e != nil {
			return res, commonErr.ReturnError(e, msg.ErrorDataConvert, "子订单金额计算失败: ")
		}
		if day != "" {
			expirationTime = day
		}
		valueAddAmount = valueAddAmount + amount
	}
	res = &bundle.PackagePriceAndTimeResponse{
		Price: float32(valueAddAmount),
		Time:  expirationTime,
	}
	return
}
func CreateOrderAddRecord(req *bundle.OrderAddRecord) (res *bundle.CommonResponse, err error) {
	tx := app.ModuleClients.BundleDB.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	orderNo := utils.GetOrderNo()
	var childOrders []*model.BundleOrderValueAdd
	for _, i := range req.AddPriceOptionsList {
		childOrder := &model.BundleOrderValueAdd{
			UUID:          app.ModuleClients.SfNode.Generate().Base64(),
			OrderUUID:     req.OrderUUID, // 修正: 这里应使用主订单UUID
			CustomerID:    req.CustomerID,
			CustomerNum:   req.CustomerNum,
			CustomerName:  req.CustomerName,
			ServiceType:   i.ServiceType,
			CurrencyType:  i.CurrencyType,
			Amount:        float64(i.Amount),
			OrderNo:       orderNo,
			Num:           i.Num,
			Unit:          i.Unit,
			ValueAddUUID:  i.ValueUid,
			Source:        2,
			PaymentStatus: 1,
			SignContract:  req.SignContract,
			Signature:     req.Signature,
			SignedTime:    req.SignedTime,
			Snapshot:      req.Snapshot,
		}
		childOrders = append(childOrders, childOrder)

		// 如果是类型5服务，更新主订单的过期时间
		if i.ServiceType == 5 && req.ExpirationDate != "" {
			if err := tx.Model(&model.BundleOrderRecords{}).
				Where("uuid = ?", req.BundleUuid).
				Update("expiration_time", req.ExpirationDate).Error; err != nil {
				tx.Rollback()
				return nil, commonErr.ReturnError(err, msg.ErrorCreateOrderInfo, "更新主订单过期时间失败: ")
			}
		}
	}
	// 批量创建子订单（提高性能）
	if err = tx.Model(&model.BundleOrderValueAdd{}).Create(childOrders).Error; err != nil {
		tx.Rollback()
		return res, commonErr.ReturnError(err, msg.ErrorCreateOrderInfo, "批量创建子订单失败")
	}

	// 提交事务
	if err := tx.Commit().Error; err != nil {
		tx.Rollback()
		return nil, commonErr.ReturnError(err, msg.ErrorCreateOrderInfo, "提交事务失败: ")
	}

	return &bundle.CommonResponse{
		Uuid:    req.BundleUuid,
		OrderNo: orderNo,
		Msg:     msg.SuccessCreateOrderInfo,
	}, nil
}
func OrderRecordsListV2(req *bundle.OrderRecordsRequestV2) (res *bundle.OrderRecordsResponseV2, err error) {
	res = new(bundle.OrderRecordsResponseV2)
	var count int64
	modelObj := app.ModuleClients.BundleDB.Model(&model.BundleOrderRecords{}).
		Select("bundle_order_records.*,a.name as bundle_name").
		Preload("BundleOrderValueAdd").
		Joins("left join bundle_profile a on bundle_order_records.bundle_uuid = a.uuid")
	//Joins("left join bundle_order_value_add on bundle_order_records.uuid = bundle_order_value_add.order_uuid")
	if len(req.UserIds) != 0 {
		modelObj = modelObj.Where("bundle_order_records.customer_id in ?", req.UserIds)
	}
	if req.BundleName != "" {
		modelObj = modelObj.Where("a.name like ?", "%"+req.BundleName+"%")
	}
	if req.PayStatus != 0 {
		modelObj = modelObj.Where("bundle_order_records.status = ?", req.PayStatus)
	}
	if req.AddPayStatus != 0 {
		modelObj = modelObj.Where("exists (select 1 from bundle_order_value_add where bundle_order_value_add.order_uuid = bundle_order_records.uuid and bundle_order_value_add.payment_status = ?)", req.AddPayStatus)
	}
	if req.OrderNo != "" {
		modelObj = modelObj.Where("bundle_order_records.order_no = ?", req.OrderNo)
	}
	if req.OrderAddNo != "" {
		modelObj = modelObj.Where("exists (select 1 from bundle_order_value_add where bundle_order_value_add.order_uuid = bundle_order_records.uuid and bundle_order_value_add.order_no = ?)", req.OrderAddNo)
	}
	if req.BundleCreateAtStart != "" && req.BundleCreateAtEnd != "" {
		modelObj = modelObj.Where("bundle_order_records.created_at between ? and ?", req.BundleCreateAtStart, req.BundleCreateAtEnd)
	}
	if req.OrderAddCreateAtStart != "" && req.OrderAddCreateAtEnd != "" {
		modelObj = modelObj.Where("bundle_order_records.created_at between ? and ?", req.OrderAddCreateAtStart, req.OrderAddCreateAtEnd)
	}
	err = modelObj.Count(&count).Error
	if req.PageSize != 0 && req.Page != 0 {
		modelObj = modelObj.Limit(int(req.PageSize)).Offset(int(req.Page-1) * int(req.PageSize))
	}
	type OrderRecords struct {
		model.BundleOrderRecords
		BundleName string `json:"bundleName"`
	}
	var records []OrderRecords
	err = modelObj.Order("bundle_order_records.created_at desc").Find(&records).Error
	if err != nil {
		return nil, err
	}
	for _, record := range records {
		customerID, _ := strconv.ParseInt(record.CustomerID, 10, 64)
		orderItem := &bundle.OrderBundleRecordInfo{
			OrderNo:        record.OrderNo,
			BundleName:     record.BundleName,
			PayStatus:      int32(record.Status),
			TelNum:         "",
			CustomerName:   record.CustomerName,
			BundleCreateAt: record.CreatedAt.Format("2006-01-02 15:04:05"),
			Amount:         record.Amount,
			CustomerId:     customerID,
		}

		// 构建子订单 map，按 orderAddNo 聚合
		addMap := make(map[string]*bundle.OrderAddBundleRecordInfo)
		for _, sub := range record.BundleOrderValueAdd {
			orderAddNo := sub.OrderNo

			// SettlementAmount 规则
			settlementAmount := float32(sub.Amount)
			if sub.OrderNo == record.OrderNo {
				settlementAmount = record.TotalAmount
			}

			if existing, ok := addMap[orderAddNo]; ok {
				existing.Amount += float32(sub.Amount)
				existing.SettlementAmount += settlementAmount
			} else {
				addMap[orderAddNo] = &bundle.OrderAddBundleRecordInfo{
					OrderAddNo:       orderAddNo,
					Amount:           float32(sub.Amount),
					SettlementAmount: settlementAmount,
					CurrencyType:     int32(sub.CurrencyType),
					//HandlingFee:      float32(sub.HandlingFee),
					//ExchangeRate:     float32(sub.ExchangeRate),
					OrderAddCreateAt:  sub.CreatedAt.Format("2006-01-02 15:04:05"),
					AddPayStatus:      int32(sub.PaymentStatus),
					Contract:          sub.SignContract,
					Snapshot:          sub.Snapshot,
					CheckoutSessionId: sub.CheckoutSessionId,
					CustomerID:        sub.CustomerID,
				}
			}
		}

		// 将聚合后的子订单添加到主订单返回结构中
		for _, v := range addMap {
			orderItem.AddBundleInfo = append(orderItem.AddBundleInfo, v)
		}
		res.BundleInfo = append(res.BundleInfo, orderItem)
	}
	res.Total = int32(count)
	res.Page = req.Page
	res.PageSize = req.PageSize
	return res, nil
}
func OrderListByOrderNo(req *bundle.OrderInfoByOrderNoRequest) (*bundle.OrderInfoByOrderNoResp, error) {
	if req == nil || req.OrderNo == "" {
		return nil, errors.New("invalid request")
	}
	var addOrder []*model.BundleOrderValueAdd
	if err := app.ModuleClients.BundleDB.Model(&model.BundleOrderValueAdd{}).
		Where("order_no = ?", req.OrderNo).
		Find(&addOrder).Error; err != nil {
		return nil, err
	}
	if len(addOrder) == 0 {
		return &bundle.OrderInfoByOrderNoResp{}, nil
	}
	//订单类型 1:套餐 2:单独购买
	userID, err := strconv.ParseInt(addOrder[0].CustomerID, 10, 64)
	if err != nil {
		return nil, err
	}
	res := &bundle.OrderInfoByOrderNoResp{
		Type:      int32(addOrder[0].Source),
		UserId:    uint64(userID),
		OrderUUID: addOrder[0].OrderUUID,
	}
	for _, item := range addOrder {
		switch item.ServiceType {
		case 1:
			res.VideoNumber += item.Num // 使用 += 而不是直接赋值
		case 2:
			res.ImageNumber += item.Num
		case 3:
			res.DataNumber += item.Num
		case 4:
			res.AccountNumber += item.Num
		case 5:
			res.Duration += item.Num
			res.Unit = item.Unit // 如果有多个duration记录，最后一个unit会覆盖前面的
		}
	}
	return res, nil
}

// 对账单
func GetReconciliationList(req *bundle.GetReconciliationListReq) (*bundle.GetReconciliationListResp, error) {
	var records []*model.Reconciliation
	res := &bundle.GetReconciliationListResp{
		Page:     req.Page,
		PageSize: req.PageSize,
	}
	modelObj := app.ModuleClients.BundleDB.Model(&model.Reconciliation{})
	if len(req.UserIDS) != 0 {
		modelObj = modelObj.Where("user_id in (?)", req.UserIDS)
	}
	if req.UserName != "" {
		modelObj = modelObj.Where("user_name like ?", "%"+req.UserName+"%")
	}
	if req.BundleName != "" {
		modelObj = modelObj.Where("bundle_name like ?", "%"+req.BundleName+"%")
	}
	if req.PayStatus != 0 {
		modelObj = modelObj.Where("pay_status = ?", req.PayStatus)
	}
	if req.PayChannel != 0 {
		modelObj = modelObj.Where("pay_channel = ?", req.PayChannel)
	}
	if req.OrderNo != "" {
		modelObj = modelObj.Where("order_no like ?", "%"+req.OrderNo+"%")
	}
	if req.CreatedStart != "" && req.CreatedEnd != "" {
		modelObj = modelObj.Where("created_at between ? and ?", req.CreatedStart, req.CreatedEnd)
	}
	if req.PayTimeStart != "" && req.PayTimeEnd != "" {
		modelObj = modelObj.Where("pay_time between ? and ?", req.PayTimeStart, req.PayTimeEnd)
	}
	if req.SerialNumber != "" {
		modelObj = modelObj.Where("serial_number like ?", "%"+req.SerialNumber+"%")
	}
	if err := modelObj.Count(&res.Total).Error; err != nil {
		return nil, fmt.Errorf("查询总数失败: %v", err)
	}
	// 无数据时提前返回
	if res.Total == 0 {
		return res, nil
	}
	offset := (req.Page - 1) * req.PageSize
	if err := modelObj.Offset(int(offset)).Limit(int(req.PageSize)).Find(&records).Error; err != nil {
		return nil, fmt.Errorf("查询记录失败: %v", err)
	}

	// 转换结果
	if err := copier.Copy(&res.List, records); err != nil {
		return nil, fmt.Errorf("数据转换失败: %v", err)
	}
	return res, nil
}
func CreateReconciliation(req *bundle.ReconciliationInfo) (res *bundle.CommonResponse, err error) {
	record := &model.Reconciliation{
		BundleOrderOn:    req.BundleOrderOn,
		BundleAddOrderOn: req.BundleAddOrderOn,
		UserID:           req.UserID,
		UserName:         req.UserName,
		UserTel:          req.UserTel,
		BundleName:       req.BundleName,
		PayAmount:        req.PayAmount,
		CurrencyType:     int(req.CurrencyType),
		PayChannel:       int(req.PayChannel),
		PayTime:          req.PayTime,
		PayStatus:        int(req.PayStatus),
		SerialNumber:     req.SerialNumber,
		CreationTime:     time.Now().Format("2006-01-02 15:04:05"),
	}

	// 创建记录
	if err := app.ModuleClients.BundleDB.Create(record).Error; err != nil {
		return nil, fmt.Errorf("创建对账单失败: %v", err)
	}

	// 返回成功响应
	return &bundle.CommonResponse{Msg: "创建对账单成功"}, nil
}
func UpdateReconciliation(req *bundle.ReconciliationInfo) (res *bundle.CommonResponse, err error) {
	var existing model.Reconciliation
	if err := app.ModuleClients.BundleDB.Where("id = ?", req.ID).First(&existing).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("对账单记录不存在")
		}
		return nil, fmt.Errorf("查询对账单失败: %v", err)
	}
	updates := model.Reconciliation{
		BundleOrderOn:    req.BundleOrderOn,
		BundleAddOrderOn: req.BundleAddOrderOn,
		UserName:         req.UserName,
		UserTel:          req.UserTel,
		BundleName:       req.BundleName,
		PayAmount:        req.PayAmount,
		CurrencyType:     int(req.CurrencyType),
		PayChannel:       int(req.PayChannel),
		PayTime:          req.PayTime,
		PayStatus:        int(req.PayStatus),
		SerialNumber:     req.SerialNumber,
	}
	if err := app.ModuleClients.BundleDB.Model(&existing).Updates(updates).Error; err != nil {
		return nil, fmt.Errorf("更新对账单失败: %v", err)
	}
	// 返回成功响应
	return &bundle.CommonResponse{Msg: "更新成功"}, nil
}