// Package gen
// @Link  https://github.com/xiujiecn/xiu-admin
// @Copyright  Copyright (c) 2026 LiXiujie
// @Author  Lxj <xxx@example.com>
// @License  https://github.com/xiujiecn/xiu-admin/blob/master/LICENSE
// @AutoGenerate Version
package iot

import (
	"context"
	"database/sql"
	"errors"
	"fmt"
	"math"
	"sort"
	"strings"

	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/consts"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/dao"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/contexts"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/xgorm"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/xgorm/handler"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/xgorm/hook"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/logic/iot/simcardbatch/addpackage"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model/entity"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/service"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/utility/convert"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/utility/excel"

	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/net/ghttp"
	"github.com/gogf/gf/v2/os/gctx"
	"github.com/gogf/gf/v2/os/gtime"
	"github.com/gogf/gf/v2/util/gconv"
)

type sIotTSimCardBindPkg struct{}

func NewIotTSimCardBindPkg() *sIotTSimCardBindPkg {
	return &sIotTSimCardBindPkg{}
}

func init() {
	service.RegisterIotTSimCardBindPkg(NewIotTSimCardBindPkg())
}

// Model 订购表ORM模型
func (s *sIotTSimCardBindPkg) Model(ctx context.Context, option ...*handler.Option) *gdb.Model {
	if len(option) == 0 {
		option = append(option, &handler.Option{
			FilterTenant: true,
			FilterAuth:   true,
		})
	}
	return handler.Model(dao.TSimCardBindPkg.Ctx(ctx), option...)
}

// List 获取订购表列表
func (s *sIotTSimCardBindPkg) List(ctx context.Context, in *model.TSimCardBindPkgListParam) (list []*model.TSimCardBindPkgListModel, totalCount int, err error) {
	mod := s.Model(ctx)
	bindPackage := dao.TSimCardBindPkg.Table()
	packageInfo := dao.TSimFlowPackageInfo.Table()

	// 先构建 Join
	mod = mod.LeftJoin(packageInfo, bindPackage+"."+dao.TSimCardBindPkg.Columns().PackageCode+" = "+packageInfo+"."+dao.TSimFlowPackageInfo.Columns().PackageCode)

	// 字段过滤（包含主表字段 + joined 表字段）
	mod = mod.FieldsPrefix(bindPackage, model.TSimCardBindPkgListModel{})
	mod = mod.Fields(packageInfo + ".package_name as packageName")
	mod = mod.WhereIn(dao.TSimCardBindPkg.Columns().PackageType, []int{101, 102})

	// 查询主键ID
	if in.Id > 0 {
		mod = mod.Where(dao.TSimCardBindPkg.Columns().Id, in.Id)
	}
	// 查询ICCID
	if in.Iccid != "" {
		mod = mod.Where(dao.TSimCardBindPkg.Columns().Iccid, in.Iccid)
	}

	// 查询订购状态 枚举
	if in.EffectiveStatus > 0 {
		mod = mod.Where(dao.TSimCardBindPkg.Columns().EffectiveStatus, in.EffectiveStatus)
	}
	// 查询类型 枚举
	if in.BusinessType != nil {
		mod = mod.Where(dao.TSimCardBindPkg.Columns().BusinessType, *in.BusinessType)
	}

	// 查询创建时间
	if len(in.CreatedAt) == 2 {
		in.CreatedAt[1] = in.CreatedAt[1].EndOfDay()
	}
	if len(in.CreatedAt) == 2 {
		mod = mod.WhereBetween(dao.TSimCardBindPkg.Columns().CreatedAt, in.CreatedAt[0], in.CreatedAt[1])
	}

	// 分页
	mod = mod.Page(in.Page, in.PageSize)

	// 排序
	mod = mod.OrderDesc(dao.TSimCardBindPkg.Columns().Id)

	// 操作人摘要信息
	mod = mod.Hook(hook.MemberSummary)

	// 查询数据
	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
		err = gerror.Wrap(err, "获取订购表列表失败，请稍后重试！")
		return
	}
	return
}

// Export 导出订购表
func (s *sIotTSimCardBindPkg) Export(ctx context.Context, in *model.TSimCardBindPkgListParam) (err error) {
	list, totalCount, err := s.List(ctx, in)
	if err != nil {
		return
	}

	// 字段的排序是依据tags的字段顺序，如果你不想使用默认的排序方式，可以直接定义 tags = []string{"字段名称", "字段名称2", ...}
	tags, err := convert.GetEntityDescTags(model.TSimCardBindPkgExportModel{})
	if err != nil {
		return
	}

	var (
		fileName  = "导出订购表-" + gctx.CtxId(ctx)
		sheetName = fmt.Sprintf("索引条件共%v行,共%v页,当前导出是第%v页,本页共%v行", totalCount, (totalCount+in.PageSize-1)/in.PageSize, in.Page, len(list))
		exports   []model.TSimCardBindPkgExportModel
	)

	if err = gconv.Scan(list, &exports); err != nil {
		return
	}

	err = excel.ExportByStructs(ctx, tags, exports, fileName, sheetName)
	return
}

// Edit 修改/新增订购表
func (s *sIotTSimCardBindPkg) Edit(ctx context.Context, in *model.TSimCardBindPkgEditParam) (err error) {
	// 验证'SubscriptionNo'唯一
	if err = xgorm.IsUnique(ctx, &dao.TSimCardBindPkg, g.Map{dao.TSimCardBindPkg.Columns().SubscriptionNo: in.SubscriptionNo}, "订购记录编号已存在", in.Id); err != nil {
		return
	}
	return g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {

		// 修改
		if in.Id > 0 {
			updatedBy := contexts.GetUserId(ctx)
			in.UpdatedBy = &updatedBy
			in.UpdatedAt = gtime.Now()
			if _, err = s.Model(ctx).
				Fields(model.TSimCardBindPkgUpdateFields{}).
				WherePri(in.Id).Data(in).Update(); err != nil {
				err = gerror.Wrap(err, "修改订购表失败，请稍后重试！")
			}
			return
		}

		// 新增
		tenantId := contexts.GetTenantId(ctx)
		in.TenantId = &tenantId
		createdDept := contexts.GetDeptId(ctx)
		in.CreatedDept = &createdDept
		createdBy := contexts.GetUserId(ctx)
		in.CreatedBy = &createdBy
		in.CreatedAt = gtime.Now()
		if _, err = s.Model(ctx, &handler.Option{FilterAuth: false}).
			Fields(model.TSimCardBindPkgInsertFields{}).
			Data(in).Insert(); err != nil {
			err = gerror.Wrap(err, "新增订购表失败，请稍后重试！")
		}
		return
	})
}

// Delete 删除订购表
func (s *sIotTSimCardBindPkg) Delete(ctx context.Context, in *model.TSimCardBindPkgDeleteParam) (err error) {

	if _, err = s.Model(ctx).WherePri(in.Id).Unscoped().Delete(); err != nil {
		err = gerror.Wrap(err, "删除订购表失败，请稍后重试！")
		return
	}
	return
}

// View 获取订购表指定信息
func (s *sIotTSimCardBindPkg) View(ctx context.Context, in *model.TSimCardBindPkgViewParam) (res *model.TSimCardBindPkgViewModel, err error) {
	if err = s.Model(ctx).WherePri(in.Id).Hook(hook.MemberSummary).Scan(&res); err != nil {
		err = gerror.Wrap(err, "获取订购表信息，请稍后重试！")
		return
	}
	return
}

// AddPackagePaymentContext 获取当前组织的加油包支付上下文。
func (s *sIotTSimCardBindPkg) AddPackagePaymentContext(ctx context.Context) (*model.TSimAddPackageOptionsRes, error) {
	return queryAddPackagePaymentContext(ctx)
}

// AddPackageOptions 获取当前卡共同可订购的加油包套餐。
func (s *sIotTSimCardBindPkg) AddPackageOptions(ctx context.Context, in *model.TSimCardAddPackageOptionsParam) (*model.TSimAddPackageOptionsRes, error) {
	if in == nil || len(in.Iccids) == 0 {
		return nil, gerror.New("ICCID不能为空")
	}
	iccids := uniqueNonEmptyStrings(in.Iccids)
	if len(iccids) == 0 {
		return nil, gerror.New("ICCID不能为空")
	}

	cardColumns := dao.TSimCardInfo.Columns()
	var cards []struct {
		Iccid         string `orm:"iccid"`
		PackageStatus int    `orm:"package_status"`
		DeptId        int64  `orm:"dept_id"`
	}
	if err := handler.Model(dao.TSimCardInfo.Ctx(ctx), &handler.Option{FilterTenant: true, FilterAuth: true}).
		Fields(cardColumns.Iccid, cardColumns.PackageStatus, cardColumns.TenantId, cardColumns.DeptId, cardColumns.CreatedDept, cardColumns.CreatedBy).
		WhereIn(cardColumns.Iccid, iccids).
		Scan(&cards); err != nil {
		return nil, gerror.Wrap(err, "查询卡信息失败")
	}
	cardMap := make(map[string]int64, len(cards))
	for _, card := range cards {
		code := strings.TrimSpace(card.Iccid)
		if code == "" {
			continue
		}
		if card.PackageStatus != consts.PackageStatusEffective {
			return nil, gerror.Newf("ICCID %s 当前套餐未生效，不能订购加油包", code)
		}
		if card.DeptId <= 0 {
			return nil, gerror.Newf("ICCID %s 未绑定客户组织", code)
		}
		cardMap[code] = card.DeptId
	}
	for _, code := range iccids {
		if _, ok := cardMap[code]; !ok {
			return nil, gerror.Newf("ICCID %s 不存在或无权限", code)
		}
	}
	if err := ensureNoActiveCardTopupPackages(ctx, iccids); err != nil {
		return nil, err
	}
	isTopDept, _, err := service.AgentDept().IsTopDept(ctx)
	if err != nil {
		return nil, gerror.Wrap(err, "判断当前组织类型失败")
	}
	availableBalance, err := queryAddPackageAvailableBalance(ctx, contexts.GetDeptId(ctx))
	if err != nil {
		return nil, err
	}

	bindColumns := dao.TSimCardBindPkg.Columns()
	var binds []struct {
		Iccid              string      `orm:"iccid"`
		PackageCode        string      `orm:"package_code"`
		ExpectedExpireTime *gtime.Time `orm:"expected_expire_time"`
	}
	if err := handler.Model(dao.TSimCardBindPkg.Ctx(ctx), &handler.Option{FilterTenant: true, FilterAuth: true}).
		Fields(bindColumns.Iccid, bindColumns.PackageCode, bindColumns.ExpectedExpireTime, bindColumns.TenantId, bindColumns.DeptId, bindColumns.CreatedDept, bindColumns.CreatedBy).
		WhereIn(bindColumns.Iccid, iccids).
		WhereIn(bindColumns.PackageType, []int{consts.PackageTypeCard, consts.PackageTypePool}).
		Where(bindColumns.EffectiveStatus, consts.EffectiveStatusEffective).
		OrderDesc(bindColumns.ExpectedExpireTime).
		OrderDesc(bindColumns.Id).
		Scan(&binds); err != nil {
		return nil, gerror.Wrap(err, "查询卡基础套餐失败")
	}
	baseCodes := make(map[string]string, len(iccids))
	for _, bind := range binds {
		iccid := strings.TrimSpace(bind.Iccid)
		if _, exists := baseCodes[iccid]; exists {
			continue
		}
		if bind.ExpectedExpireTime != nil && !bind.ExpectedExpireTime.After(gtime.Now()) {
			continue
		}
		baseCodes[iccid] = strings.TrimSpace(bind.PackageCode)
	}
	for _, code := range iccids {
		if baseCodes[code] == "" {
			return nil, gerror.Newf("ICCID %s 当前没有正在生效中的基础套餐", code)
		}
	}

	packageCodes := make([]string, 0, len(baseCodes))
	for _, code := range baseCodes {
		packageCodes = append(packageCodes, code)
	}
	packageColumns := dao.TSimFlowPackageInfo.Columns()
	var packages []*entity.TSimFlowPackageInfo
	if err := handler.Model(dao.TSimFlowPackageInfo.Ctx(ctx), &handler.Option{FilterTenant: true, FilterAuth: false}).
		Fields(packageColumns.PackageCode, packageColumns.TopupPackageCodes).
		WhereIn(packageColumns.PackageCode, uniqueNonEmptyStrings(packageCodes)).
		Scan(&packages); err != nil {
		return nil, gerror.Wrap(err, "查询基础套餐配置失败")
	}
	packageMap := make(map[string]*entity.TSimFlowPackageInfo, len(packages))
	for _, pkg := range packages {
		if pkg != nil {
			packageMap[strings.TrimSpace(pkg.PackageCode)] = pkg
		}
	}

	var commonCodes map[string]struct{}
	for _, code := range iccids {
		base := packageMap[baseCodes[code]]
		if base == nil {
			return nil, gerror.Newf("基础套餐不存在：%s", baseCodes[code])
		}
		allowed := make(map[string]struct{})
		for _, topupCode := range packageCodesFromJSON(base.TopupPackageCodes) {
			allowed[topupCode] = struct{}{}
		}
		if len(allowed) == 0 {
			return nil, gerror.Newf("基础套餐未配置可购加油包：%s", baseCodes[code])
		}
		if commonCodes == nil {
			commonCodes = allowed
			continue
		}
		for candidate := range commonCodes {
			if _, ok := allowed[candidate]; !ok {
				delete(commonCodes, candidate)
			}
		}
	}
	if len(commonCodes) == 0 {
		return nil, gerror.New("所选卡没有共同可购的加油包套餐")
	}

	var addPackages []*entity.TSimFlowPackageInfo
	if err := handler.Model(dao.TSimFlowPackageInfo.Ctx(ctx), &handler.Option{FilterTenant: true, FilterAuth: false}).
		Fields(
			packageColumns.PackageCode,
			packageColumns.PackageName,
			packageColumns.FlowMb,
			packageColumns.CostPrice,
			packageColumns.TerminalCost,
			packageColumns.SysDefaultRatio,
			packageColumns.SysDefaultProfit,
			packageColumns.SysDefaultTerminalRatio,
			packageColumns.SysDefaultTerminalProfit,
		).
		WhereIn(packageColumns.PackageCode, mapKeys(commonCodes)).
		Where(packageColumns.PackageType, consts.PackageTypeCardAddPackage).
		Where(packageColumns.Enabled, 1).
		OrderAsc(packageColumns.SortNo).
		Scan(&addPackages); err != nil {
		return nil, gerror.Wrap(err, "查询单卡加油包套餐失败")
	}
	items := make([]*model.TSimAddPackageOptionModel, 0, len(addPackages))
	for _, pkg := range addPackages {
		if pkg == nil {
			continue
		}
		var totalAmount float64
		var unitPrice float64
		priceAvailable := true
		uniformPrice := true
		paymentAccounts := make(map[int64]*model.TSimAddPackagePaymentAccountModel)
		for index, iccid := range iccids {
			customerDeptID := cardMap[iccid]
			priceOwnerDeptID, err := loadPackagePriceParentDeptID(ctx, nil, contexts.GetTenantId(ctx), customerDeptID)
			if err != nil {
				return nil, err
			}
			salePrice, err := resolvePackageEffectiveSalePrice(
				ctx,
				nil,
				contexts.GetTenantId(ctx),
				priceOwnerDeptID,
				customerDeptID,
				packagePriceSourceFromEntity(pkg),
			)
			if err != nil {
				priceAvailable = false
				break
			}
			if index == 0 {
				unitPrice = salePrice.AgentShipmentPrice
			} else if math.Abs(unitPrice-salePrice.AgentShipmentPrice) > 0.0001 {
				uniformPrice = false
			}
			totalAmount = roundAmount(totalAmount + salePrice.AgentShipmentPrice)
			account := paymentAccounts[customerDeptID]
			if account == nil {
				balance, err := queryAddPackageAvailableBalance(ctx, customerDeptID)
				if err != nil {
					return nil, err
				}
				account = &model.TSimAddPackagePaymentAccountModel{
					PayerDeptId:      customerDeptID,
					AvailableBalance: balance,
				}
				paymentAccounts[customerDeptID] = account
			}
			account.TargetCount++
			account.RequiredAmount = roundAmount(account.RequiredAmount + salePrice.AgentShipmentPrice)
		}
		paymentAccountItems := make([]*model.TSimAddPackagePaymentAccountModel, 0, len(paymentAccounts))
		for _, account := range paymentAccounts {
			account.BalanceEnough = account.AvailableBalance+0.0001 >= account.RequiredAmount
			paymentAccountItems = append(paymentAccountItems, account)
		}
		if !uniformPrice {
			unitPrice = 0
		}
		items = append(items, &model.TSimAddPackageOptionModel{
			PackageCode:     strings.TrimSpace(pkg.PackageCode),
			PackageName:     strings.TrimSpace(pkg.PackageName),
			FlowMb:          pkg.FlowMb,
			UnitPrice:       unitPrice,
			TotalAmount:     totalAmount,
			PriceAvailable:  priceAvailable,
			PaymentAccounts: paymentAccountItems,
		})
	}
	return &model.TSimAddPackageOptionsRes{
		Items:              items,
		IsTopDept:          isTopDept,
		DefaultPaymentMode: addPackageDefaultPaymentMode(isTopDept),
		AvailableBalance:   availableBalance,
	}, nil
}

func uniqueNonEmptyStrings(values []string) []string {
	seen := make(map[string]struct{}, len(values))
	result := make([]string, 0, len(values))
	for _, value := range values {
		value = strings.TrimSpace(value)
		if value == "" {
			continue
		}
		if _, ok := seen[value]; ok {
			continue
		}
		seen[value] = struct{}{}
		result = append(result, value)
	}
	return result
}

func mapKeys(values map[string]struct{}) []string {
	keys := make([]string, 0, len(values))
	for key := range values {
		keys = append(keys, key)
	}
	sort.Strings(keys)
	return keys
}

func ensureNoActiveCardTopupPackages(ctx context.Context, iccids []string) error {
	iccids = uniqueNonEmptyStrings(iccids)
	if len(iccids) == 0 {
		return nil
	}
	c := dao.TSimCardBindPkg.Columns()
	var row struct {
		Iccid string `orm:"iccid"`
	}
	if err := handler.Model(dao.TSimCardBindPkg.Ctx(ctx), &handler.Option{FilterTenant: true, FilterAuth: true}).
		Fields(c.Iccid).
		WhereIn(c.Iccid, iccids).
		Where(c.PackageType, consts.PackageTypeCardAddPackage).
		WhereIn(c.EffectiveStatus, []int{consts.EffectiveStatusPending, consts.EffectiveStatusEffective}).
		Where(fmt.Sprintf("(%s IS NULL OR %s > ?)", c.ExpectedExpireTime, c.ExpectedExpireTime), gtime.Now()).
		OrderAsc(c.Id).
		Limit(1).
		Scan(&row); err != nil && !errors.Is(err, sql.ErrNoRows) {
		return gerror.Wrap(err, "查询未过期单卡加油包失败")
	}
	if iccid := strings.TrimSpace(row.Iccid); iccid != "" {
		return gerror.Newf("ICCID %s 存在未过期加油包，不能重复订购", iccid)
	}
	return nil
}

func ensureNoActivePoolTopupPackages(ctx context.Context, poolCodes []string) error {
	poolCodes = uniqueNonEmptyStrings(poolCodes)
	if len(poolCodes) == 0 {
		return nil
	}
	c := dao.TSimPoolBindPackage.Columns()
	var row struct {
		PoolNo string `orm:"pool_no"`
	}
	if err := handler.Model(dao.TSimPoolBindPackage.Ctx(ctx), &handler.Option{FilterTenant: true, FilterAuth: true}).
		Fields(c.PoolNo).
		WhereIn(c.PoolNo, poolCodes).
		Where(c.PackageType, consts.PackageTypePoolAddPackage).
		WhereIn(c.EffectiveStatus, []int{consts.EffectiveStatusPending, consts.EffectiveStatusEffective}).
		Where(fmt.Sprintf("(%s IS NULL OR %s > ?)", c.ExpectedExpireTime, c.ExpectedExpireTime), gtime.Now()).
		OrderAsc(c.Id).
		Limit(1).
		Scan(&row); err != nil && !errors.Is(err, sql.ErrNoRows) {
		return gerror.Wrap(err, "查询未过期流量池加油包失败")
	}
	if poolNo := strings.TrimSpace(row.PoolNo); poolNo != "" {
		return gerror.Newf("流量池 %s 存在未过期加油包，不能重复订购", poolNo)
	}
	return nil
}

// 套餐详情查询
func (s *sIotTSimCardBindPkg) GetPkgInfo(ctx context.Context, in *model.TSimCardBindPkgInfoParam) (list []*model.TSimCardBindPkgListModel, totalCount int, err error) {
	mod := s.Model(ctx)
	bindPackage := dao.TSimCardBindPkg.Table()
	packageInfo := dao.TSimFlowPackageInfo.Table()
	orderTable := dao.TOrder.Table()

	// 先构建 Join
	mod = mod.LeftJoin(packageInfo, bindPackage+"."+dao.TSimCardBindPkg.Columns().PackageCode+" = "+packageInfo+"."+dao.TSimFlowPackageInfo.Columns().PackageCode)
	mod = mod.LeftJoin(orderTable, "CONVERT("+bindPackage+"."+dao.TSimCardBindPkg.Columns().OrderCode+" USING utf8mb4) = "+orderTable+"."+dao.TOrder.Columns().OrderSn)

	// 字段过滤（包含主表字段 + joined 表字段）
	mod = mod.FieldsPrefix(bindPackage, model.TSimCardBindPkgListModel{})
	mod = mod.Fields(packageInfo + ".package_name as packageName")
	mod = mod.Fields(packageInfo + ".flow_mb as packageFlowMb")
	mod = mod.Fields(packageInfo + ".flow_gb as packageFlowGb")
	mod = mod.Fields(orderTable + ".pay_type as payType")
	mod = mod.Fields(orderTable + ".pay_status as payStatus")
	mod = mod.Fields(orderTable + ".pay_time as payTime")
	mod = mod.Fields(orderTable + ".total_amount as totalAmount")
	mod = mod.Fields(orderTable + ".paid_amount as paidAmount")
	mod = mod.Fields(orderTable + ".balance as balance")

	// 查询ICCID
	if in.Iccid != "" {
		mod = mod.Where(dao.TSimCardBindPkg.Columns().Iccid, in.Iccid)
	}
	mod = mod.Where(dao.TSimCardBindPkg.Columns().PackageType, 103)

	// 分页
	mod = mod.Page(in.Page, in.PageSize)

	// 排序
	mod = mod.OrderDesc(dao.TSimCardBindPkg.Columns().Id)

	// 操作人摘要信息
	mod = mod.Hook(hook.MemberSummary)

	// 查询数据
	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
		err = gerror.Wrap(err, "获取订购表列表失败，请稍后重试！")
		return
	}
	return
}

// 变更套餐
func (s *sIotTSimCardBindPkg) GetChangePkg(ctx context.Context, in *model.TSimCardBindPkgInfoParam) (list []*model.TSimCardBindPkgListModel, totalCount int, err error) {
	mod := s.Model(ctx)
	bindPackage := dao.TSimCardBindPkg.Table()
	packageInfo := dao.TSimFlowPackageInfo.Table()

	// 构建 Join - 关联当前套餐信息（变更后）
	mod = mod.LeftJoin(packageInfo+" as curr_pkg", bindPackage+"."+dao.TSimCardBindPkg.Columns().PackageCode+" = curr_pkg."+dao.TSimFlowPackageInfo.Columns().PackageCode)
	// 构建 Join - 关联变更前套餐信息
	mod = mod.LeftJoin(packageInfo+" as prev_pkg", bindPackage+"."+dao.TSimCardBindPkg.Columns().PreviousPackageCode+" = prev_pkg."+dao.TSimFlowPackageInfo.Columns().PackageCode)

	// 字段过滤（包含主表字段 + joined 表字段）
	mod = mod.FieldsPrefix(bindPackage, model.TSimCardBindPkgListModel{})
	mod = mod.Fields("curr_pkg.package_name as packageName")
	mod = mod.Fields("prev_pkg.package_name as previousPackageName")

	// 查询ICCID
	mod = mod.Where(bindPackage+"."+dao.TSimCardBindPkg.Columns().Iccid, in.Iccid)
	mod = mod.Where("("+bindPackage+"."+dao.TSimCardBindPkg.Columns().BusinessType+" = ? OR "+bindPackage+"."+dao.TSimCardBindPkg.Columns().BatchNo+" LIKE ?)", consts.PackageBusinessTypeChange, "CHG%")
	// 分页
	mod = mod.Page(in.Page, in.PageSize)

	// 排序
	mod = mod.OrderDesc(dao.TSimCardBindPkg.Columns().Id)

	// 操作人摘要信息
	mod = mod.Hook(hook.MemberSummary)

	// 查询数据
	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
		err = gerror.Wrap(err, "获取订购表列表失败，请稍后重试！")
		return
	}
	return
}

func (s *sIotTSimCardBindPkg) DownloadExcelTemplate(ctx context.Context) error {
	return addpackage.NewCardSubmitter().DownloadTemplate(ctx)
}

func (s *sIotTSimCardBindPkg) SubmitExcel(ctx context.Context, in *model.TSimCardBindPkgAddPackageExcelSubmitParam) (*model.TSimCardBindPkgAddPackageExcelSubmitRes, error) {
	if in == nil {
		in = &model.TSimCardBindPkgAddPackageExcelSubmitParam{}
	}
	file, err := cardAddPackageUploadFile(ctx)
	if err != nil {
		return nil, err
	}
	paymentMode, offlineContractCompleted, err := normalizeAddPackagePaymentMode(ctx, in.PaymentMode, in.OfflineContractCompleted)
	if err != nil {
		return nil, err
	}
	result, err := addpackage.NewCardSubmitter().SubmitExcel(ctx, file, addpackage.SubmitOptions{
		PaymentMode:              paymentMode,
		OfflineContractCompleted: offlineContractCompleted,
		ManualConfirm:            in.ManualConfirm,
	})
	if err != nil {
		return nil, err
	}
	return cardAddPackageSubmitRes(result), nil
}

func (s *sIotTSimCardBindPkg) SubmitInput(ctx context.Context, in *model.TSimCardBindPkgAddPackageInputSubmitParam) (*model.TSimCardBindPkgAddPackageInputSubmitRes, error) {
	if in == nil {
		in = &model.TSimCardBindPkgAddPackageInputSubmitParam{}
	}
	paymentMode, offlineContractCompleted, err := normalizeAddPackagePaymentMode(ctx, in.PaymentMode, in.OfflineContractCompleted)
	if err != nil {
		return nil, err
	}
	result, err := addpackage.NewCardSubmitter().SubmitInput(ctx, in.Input, addpackage.SubmitOptions{
		PackageCode:              in.PackageCode,
		Remark:                   in.Remark,
		PaymentMode:              paymentMode,
		OfflineContractCompleted: offlineContractCompleted,
		EffectiveMode:            in.EffectiveMode,
	})
	if err != nil {
		return nil, err
	}
	return (*model.TSimCardBindPkgAddPackageInputSubmitRes)(cardAddPackageSubmitRes(result)), nil
}

func cardAddPackageUploadFile(ctx context.Context) (*ghttp.UploadFile, error) {
	r := g.RequestFromCtx(ctx)
	if r == nil {
		return nil, gerror.New("当前上下文不是HTTP请求")
	}
	file := r.GetUploadFile("file")
	if file == nil {
		return nil, gerror.New("请选择上传文件")
	}
	return file, nil
}

func cardAddPackageSubmitRes(result *addpackage.SubmitResult) *model.TSimCardBindPkgAddPackageBatchSubmitRes {
	res := &model.TSimCardBindPkgAddPackageBatchSubmitRes{}
	if result == nil {
		return res
	}
	res.BatchNo = result.BatchNo
	res.BatchType = result.BatchType
	res.TargetBatchType = result.TargetBatchType
	res.BatchAsyncStatus = result.BatchAsyncStatus
	res.Total = result.Total
	res.ValidCount = result.ValidCount
	res.FailCount = result.FailCount
	return res
}