// Package asset 提供统一的资产查询与操作服务
// 资产包含两种类型：IoT卡(card)和设备(device)
// 支持资产解析、实时状态查询、网关刷新、套餐查询等功能
package asset

import (
	"context"
	stderrors "errors"
	"sort"
	"time"

	"github.com/break/junhong_cmp_fiber/internal/gateway"
	"github.com/break/junhong_cmp_fiber/internal/model"
	"github.com/break/junhong_cmp_fiber/internal/model/dto"
	"github.com/break/junhong_cmp_fiber/internal/store/postgres"
	"github.com/break/junhong_cmp_fiber/pkg/constants"
	"github.com/break/junhong_cmp_fiber/pkg/errors"
	"github.com/break/junhong_cmp_fiber/pkg/logger"
	"github.com/break/junhong_cmp_fiber/pkg/middleware"
	"github.com/redis/go-redis/v9"
	"go.uber.org/zap"
	"gorm.io/gorm"
)

// IotCardRefresher 用于调用 RefreshCardDataFromGateway，避免循环依赖
type IotCardRefresher interface {
	RefreshCardDataFromGateway(ctx context.Context, iccid string) error
}

// Service 资产查询与操作服务
type Service struct {
	db                    *gorm.DB
	deviceStore           *postgres.DeviceStore
	iotCardStore          *postgres.IotCardStore
	packageUsageStore     *postgres.PackageUsageStore
	packageStore          *postgres.PackageStore
	packageSeriesStore    *postgres.PackageSeriesStore
	deviceSimBindingStore *postgres.DeviceSimBindingStore
	shopStore             *postgres.ShopStore
	redis                 *redis.Client
	iotCardService        IotCardRefresher
	gatewayClient         *gateway.Client // 用于调用 sync-info 同步设备信息（可为 nil，失败时仅记录日志）
}

// New 创建资产服务实例
func New(
	db *gorm.DB,
	deviceStore *postgres.DeviceStore,
	iotCardStore *postgres.IotCardStore,
	packageUsageStore *postgres.PackageUsageStore,
	packageStore *postgres.PackageStore,
	packageSeriesStore *postgres.PackageSeriesStore,
	deviceSimBindingStore *postgres.DeviceSimBindingStore,
	shopStore *postgres.ShopStore,
	redisClient *redis.Client,
	iotCardService IotCardRefresher,
	gatewayClient *gateway.Client,
) *Service {
	return &Service{
		db:                    db,
		deviceStore:           deviceStore,
		iotCardStore:          iotCardStore,
		packageUsageStore:     packageUsageStore,
		packageStore:          packageStore,
		packageSeriesStore:    packageSeriesStore,
		deviceSimBindingStore: deviceSimBindingStore,
		shopStore:             shopStore,
		redis:                 redisClient,
		iotCardService:        iotCardService,
		gatewayClient:         gatewayClient,
	}
}

// Resolve 通过任意标识符解析资产
// 优先匹配设备（virtual_no/imei/sn），未命中则匹配卡（virtual_no/iccid/msisdn）
func (s *Service) Resolve(ctx context.Context, identifier string) (*dto.AssetResolveResponse, error) {
	// 先查 Device
	device, err := s.deviceStore.GetByIdentifier(ctx, identifier)
	if err == nil && device != nil {
		return s.buildDeviceResolveResponse(ctx, device)
	}

	// 未找到设备，查 IotCard（virtual_no/iccid/msisdn）
	var card model.IotCard
	query := s.db.WithContext(ctx).
		Where("virtual_no = ? OR iccid = ? OR msisdn = ?", identifier, identifier, identifier)
	query = middleware.ApplyShopFilter(ctx, query)
	if err := query.First(&card).Error; err == nil {
		return s.buildCardResolveResponse(ctx, &card)
	}

	return nil, errors.New(errors.CodeNotFound, "未找到匹配的资产")
}

// buildDeviceResolveResponse 构建设备类型的资产解析响应
func (s *Service) buildDeviceResolveResponse(ctx context.Context, device *model.Device) (*dto.AssetResolveResponse, error) {
	resp := &dto.AssetResolveResponse{
		AssetType:           "device",
		AssetID:             device.ID,
		VirtualNo:           device.VirtualNo,
		Status:              device.Status,
		BatchNo:             device.BatchNo,
		ShopID:              device.ShopID,
		SeriesID:            device.SeriesID,
		FirstCommissionPaid: device.FirstCommissionPaid,
		AccumulatedRecharge: device.AccumulatedRecharge,
		ActivatedAt:         device.ActivatedAt,
		CreatedAt:           device.CreatedAt,
		UpdatedAt:           device.UpdatedAt,
		DeviceName:          device.DeviceName,
		IMEI:                device.IMEI,
		SN:                  device.SN,
		DeviceModel:         device.DeviceModel,
		DeviceType:          device.DeviceType,
		MaxSimSlots:         device.MaxSimSlots,
		Manufacturer:        device.Manufacturer,
		OnlineStatus:        device.OnlineStatus,
		LastOnlineTime:      device.LastOnlineTime,
		SoftwareVersion:     device.SoftwareVersion,
		SwitchMode:          device.SwitchMode,
		LastGatewaySyncAt:   device.LastGatewaySyncAt,
	}

	// 查绑定卡
	bindings, err := s.deviceSimBindingStore.ListByDeviceID(ctx, device.ID)
	if err == nil && len(bindings) > 0 {
		resp.BoundCardCount = len(bindings)
		cardIDs := make([]uint, 0, len(bindings))
		slotMap := make(map[uint]int, len(bindings))
		isCurrentMap := make(map[uint]bool, len(bindings))
		for _, b := range bindings {
			cardIDs = append(cardIDs, b.IotCardID)
			slotMap[b.IotCardID] = b.SlotPosition
			isCurrentMap[b.IotCardID] = b.IsCurrent
		}
		cards, err := s.iotCardStore.GetByIDs(ctx, cardIDs)
		if err != nil {
			logger.GetAppLogger().Warn("查询设备绑定卡信息失败，结果可能不完整",
				zap.Uints("card_ids", cardIDs),
				zap.Error(err))
		}
		for _, c := range cards {
			resp.Cards = append(resp.Cards, dto.BoundCardInfo{
				CardID:         c.ID,
				ICCID:          c.ICCID,
				MSISDN:         c.MSISDN,
				NetworkStatus:  c.NetworkStatus,
				RealNameStatus: c.RealNameStatus,
				SlotPosition:   slotMap[c.ID],
				IsCurrent:      isCurrentMap[c.ID],
			})
		}
	}

	// 查当前主套餐
	s.fillPackageInfo(ctx, resp, "device", device.ID)

	// 查 shop 名称
	s.fillShopName(ctx, resp)

	// 查套餐系列名称
	s.fillSeriesName(ctx, resp)

	// 查 Redis 保护期
	resp.DeviceProtectStatus = s.getDeviceProtectStatus(ctx, device.ID)

	return resp, nil
}

// buildCardResolveResponse 构建卡类型的资产解析响应
func (s *Service) buildCardResolveResponse(ctx context.Context, card *model.IotCard) (*dto.AssetResolveResponse, error) {
	resp := &dto.AssetResolveResponse{
		AssetType:           "card",
		AssetID:             card.ID,
		VirtualNo:           card.VirtualNo,
		Status:              card.Status,
		BatchNo:             card.BatchNo,
		ShopID:              card.ShopID,
		SeriesID:            card.SeriesID,
		FirstCommissionPaid: card.FirstCommissionPaid,
		AccumulatedRecharge: card.AccumulatedRecharge,
		ActivatedAt:         card.ActivatedAt,
		CreatedAt:           card.CreatedAt,
		UpdatedAt:           card.UpdatedAt,
		RealNameStatus:      card.RealNameStatus,
		NetworkStatus:       card.NetworkStatus,
		ICCID:               card.ICCID,
		CarrierID:           card.CarrierID,
		CarrierType:         card.CarrierType,
		CarrierName:         card.CarrierName,
		MSISDN:              card.MSISDN,
		IMSI:                card.IMSI,
		CardCategory:        card.CardCategory,
		Supplier:            card.Supplier,
		ActivationStatus:    card.ActivationStatus,
		EnablePolling:       card.EnablePolling,
	}

	// 查绑定设备
	binding, err := s.deviceSimBindingStore.GetActiveBindingByCardID(ctx, card.ID)
	if err == nil && binding != nil {
		resp.BoundDeviceID = &binding.DeviceID
		device, devErr := s.deviceStore.GetByID(ctx, binding.DeviceID)
		if devErr == nil && device != nil {
			resp.BoundDeviceNo = device.VirtualNo
			resp.BoundDeviceName = device.DeviceName
		}
	}

	// 查当前主套餐
	s.fillPackageInfo(ctx, resp, "iot_card", card.ID)

	// 查 shop 名称
	s.fillShopName(ctx, resp)

	// 查套餐系列名称
	s.fillSeriesName(ctx, resp)

	return resp, nil
}

// fillPackageInfo 填充当前主套餐信息到响应中
func (s *Service) fillPackageInfo(ctx context.Context, resp *dto.AssetResolveResponse, carrierType string, carrierID uint) {
	usage, err := s.packageUsageStore.GetActiveMainPackage(ctx, carrierType, carrierID)
	if err != nil || usage == nil {
		return
	}

	pkg, err := s.packageStore.GetByID(ctx, usage.PackageID)
	if err != nil || pkg == nil {
		return
	}

	resp.CurrentPackage = pkg.PackageName
	ratio := safeVirtualRatio(pkg.VirtualRatio)
	resp.PackageTotalMB = int64(float64(usage.DataLimitMB) / ratio)
	resp.PackageUsedMB = float64(usage.DataUsageMB) / ratio
	resp.PackageRemainMB = float64(usage.DataLimitMB-usage.DataUsageMB) / ratio
}

// fillShopName 填充店铺名称
func (s *Service) fillShopName(ctx context.Context, resp *dto.AssetResolveResponse) {
	if resp.ShopID == nil || *resp.ShopID == 0 {
		return
	}
	shop, err := s.shopStore.GetByID(ctx, *resp.ShopID)
	if err == nil && shop != nil {
		resp.ShopName = shop.ShopName
	}
}

// fillSeriesName 填充套餐系列名称
func (s *Service) fillSeriesName(ctx context.Context, resp *dto.AssetResolveResponse) {
	if resp.SeriesID == nil || *resp.SeriesID == 0 {
		return
	}
	series, err := s.packageSeriesStore.GetByID(ctx, *resp.SeriesID)
	if err == nil && series != nil {
		resp.SeriesName = series.SeriesName
	}
}

// GetRealtimeStatus 获取资产实时状态（只读DB/Redis）
func (s *Service) GetRealtimeStatus(ctx context.Context, assetType string, id uint) (*dto.AssetRealtimeStatusResponse, error) {
	resp := &dto.AssetRealtimeStatusResponse{
		AssetType: assetType,
		AssetID:   id,
	}

	switch assetType {
	case "card":
		card, err := s.iotCardStore.GetByID(ctx, id)
		if err != nil {
			return nil, errors.Wrap(errors.CodeNotFound, err, "卡不存在")
		}
		resp.NetworkStatus = card.NetworkStatus
		resp.RealNameStatus = card.RealNameStatus
		resp.CurrentMonthUsageMB = card.CurrentMonthUsageMB
		resp.LastSyncTime = card.LastSyncTime

	case "device":
		// 查绑定卡状态列表
		bindings, err := s.deviceSimBindingStore.ListByDeviceID(ctx, id)
		if err == nil && len(bindings) > 0 {
			cardIDs := make([]uint, 0, len(bindings))
			slotMap := make(map[uint]int, len(bindings))
			isCurrentMap := make(map[uint]bool, len(bindings))
			for _, b := range bindings {
				cardIDs = append(cardIDs, b.IotCardID)
				slotMap[b.IotCardID] = b.SlotPosition
				isCurrentMap[b.IotCardID] = b.IsCurrent
			}
			cards, err := s.iotCardStore.GetByIDs(ctx, cardIDs)
			if err != nil {
				logger.GetAppLogger().Warn("查询设备绑定卡信息失败，结果可能不完整",
					zap.Uints("card_ids", cardIDs),
					zap.Error(err))
			}
			for _, c := range cards {
				resp.Cards = append(resp.Cards, dto.BoundCardInfo{
					CardID:         c.ID,
					ICCID:          c.ICCID,
					MSISDN:         c.MSISDN,
					NetworkStatus:  c.NetworkStatus,
					RealNameStatus: c.RealNameStatus,
					SlotPosition:   slotMap[c.ID],
					IsCurrent:      isCurrentMap[c.ID],
				})
			}
		}
		resp.DeviceProtectStatus = s.getDeviceProtectStatus(ctx, id)

		// 实时查询 Gateway 设备状态（不缓存，per D-05）
		// Gateway 失败不阻断主流程，DeviceRealtime 始终非 nil，失败时仅填 GatewayMsg（per D-06）
		resp.DeviceRealtime = s.fetchDeviceGatewayInfo(ctx, id)

	default:
		return nil, errors.New(errors.CodeInvalidParam, "不支持的资产类型，仅支持 card 或 device")
	}

	return resp, nil
}

// fetchDeviceGatewayInfo 查询设备 Gateway 实时状态，始终返回非 nil 对象
// Gateway 成功时填充全量字段，失败时仅填充 GatewayMsg 供前端展示错误原因
func (s *Service) fetchDeviceGatewayInfo(ctx context.Context, deviceID uint) *dto.DeviceGatewayInfo {
	if s.gatewayClient == nil {
		msg := "Gateway 客户端未配置"
		return &dto.DeviceGatewayInfo{GatewayMsg: &msg}
	}

	device, err := s.deviceStore.GetByID(ctx, deviceID)
	if err != nil {
		msg := "查询设备信息失败: " + err.Error()
		return &dto.DeviceGatewayInfo{GatewayMsg: &msg}
	}

	// IMEI 优先，无则用 SN（与 Refresh 中 updateDeviceFromSyncInfo 保持一致）
	cardNo := device.IMEI
	if cardNo == "" {
		cardNo = device.SN
	}
	if cardNo == "" {
		msg := "设备缺少 IMEI 和 SN，无法查询 Gateway 实时状态"
		return &dto.DeviceGatewayInfo{GatewayMsg: &msg}
	}

	syncResp, syncErr := s.gatewayClient.SyncDeviceInfo(ctx, &gateway.SyncDeviceInfoReq{
		CardNo: cardNo,
	})
	if syncErr != nil {
		msg := syncErr.Error()
		logger.GetAppLogger().Warn("fetchDeviceGatewayInfo: sync-info 调用失败",
			zap.Uint("device_id", deviceID),
			zap.Error(syncErr))
		return &dto.DeviceGatewayInfo{GatewayMsg: &msg}
	}

	return mapSyncRespToDeviceGatewayInfo(syncResp)
}

// mapSyncRespToDeviceGatewayInfo 将 Gateway SyncDeviceInfoResp 映射为 B 端 DeviceGatewayInfo DTO
// 使用指针字段，未赋值的字段保持 nil（omitempty）
func mapSyncRespToDeviceGatewayInfo(r *gateway.SyncDeviceInfoResp) *dto.DeviceGatewayInfo {
	info := &dto.DeviceGatewayInfo{
		OnlineStatus:    &r.OnlineStatus,
		RunTime:         strPtr(r.RunTime),
		ConnectTime:     strPtr(r.ConnectTime),
		LastOnlineTime:  strPtr(r.LastOnlineTime),
		LastUpdateTime:  strPtr(r.LastUpdateTime),
		Rsrp:            &r.Rsrp,
		Rsrq:            &r.Rsrq,
		Rssi:            strPtr(r.RSSI),
		Sinr:            &r.Sinr,
		SSID:            strPtr(r.SSID),
		WifiEnabled:     &r.WifiEnabled,
		WifiPassword:    strPtr(r.WifiPassword),
		IPAddress:       strPtr(r.IPAddress),
		WANIP:           strPtr(r.WANIP),
		LANIP:           strPtr(r.LANIP),
		MACAddress:      strPtr(r.MacAddress),
		DailyUsage:      strPtr(r.DailyUsage),
		DLStats:         strPtr(r.DLStats),
		ULStats:         strPtr(r.ULStats),
		LimitSpeed:      &r.LimitSpeed,
		CurrentIccid:    strPtr(r.CurrentIccid),
		MaxClients:      &r.MaxClients,
		SoftwareVersion: strPtr(r.SoftwareVersion),
		SwitchMode:      strPtr(r.SwitchMode),
		SyncInterval:    &r.SyncInterval,
		DeviceID:        strPtr(r.DeviceID),
		DeviceName:      strPtr(r.DeviceName),
		DeviceType:      strPtr(r.DeviceType),
		IMEI:            strPtr(r.IMEI),
		IMSI:            strPtr(r.IMSI),
		Status:          &r.Status,
	}
	if r.BatteryLevel != nil {
		info.BatteryLevel = r.BatteryLevel
	}
	return info
}

// strPtr 将空字符串转为 nil，非空字符串返回指针
// 避免 JSON 响应中出现大量空字符串字段（omitempty 对空字符串无效）
func strPtr(s string) *string {
	if s == "" {
		return nil
	}
	return &s
}

// Refresh 刷新资产数据（调网关同步）
func (s *Service) Refresh(ctx context.Context, assetType string, id uint) (*dto.AssetRealtimeStatusResponse, error) {
	switch assetType {
	case "card":
		card, err := s.iotCardStore.GetByID(ctx, id)
		if err != nil {
			return nil, errors.Wrap(errors.CodeNotFound, err, "卡不存在")
		}
		if err := s.iotCardService.RefreshCardDataFromGateway(ctx, card.ICCID); err != nil {
			return nil, errors.Wrap(errors.CodeInternalError, err, "刷新卡数据失败")
		}
		return s.GetRealtimeStatus(ctx, "card", id)

	case "device":
		// 检查冷却期
		cooldownKey := constants.RedisDeviceRefreshCooldownKey(id)
		if s.redis.Exists(ctx, cooldownKey).Val() > 0 {
			return nil, errors.New(errors.CodeTooManyRequests, "刷新过于频繁，请30秒后再试")
		}

		// 查所有绑定卡，逐一刷新
		bindings, err := s.deviceSimBindingStore.ListByDeviceID(ctx, id)
		if err != nil {
			return nil, errors.Wrap(errors.CodeInternalError, err, "查询绑定卡失败")
		}
		for _, b := range bindings {
			card, cardErr := s.iotCardStore.GetByID(ctx, b.IotCardID)
			if cardErr != nil {
				logger.GetAppLogger().Warn("刷新设备绑定卡失败：查卡失败",
					zap.Uint("device_id", id),
					zap.Uint("card_id", b.IotCardID),
					zap.Error(cardErr))
				continue
			}
			if refreshErr := s.iotCardService.RefreshCardDataFromGateway(ctx, card.ICCID); refreshErr != nil {
				logger.GetAppLogger().Warn("刷新设备绑定卡失败：网关调用失败",
					zap.Uint("device_id", id),
					zap.String("iccid", card.ICCID),
					zap.Error(refreshErr))
			}
		}

		// 设置冷却 Key
		s.redis.Set(ctx, cooldownKey, 1, constants.DeviceRefreshCooldownDuration)

		// 刷新设备自身信息（在线状态、当前卡、固件版本等），失败不阻断刷新流程（per D-15）
		if s.gatewayClient != nil {
			device, devErr := s.deviceStore.GetByID(ctx, id)
			if devErr == nil {
				// IMEI 优先，无则用 SN（per D-3 注释说明）
				cardNo := device.IMEI
				if cardNo == "" {
					cardNo = device.SN
				}
				if cardNo != "" {
					if syncResp, syncErr := s.gatewayClient.SyncDeviceInfo(ctx, &gateway.SyncDeviceInfoReq{
						CardNo: cardNo,
					}); syncErr == nil {
						s.updateDeviceFromSyncInfo(ctx, id, syncResp)
					} else {
						logger.GetAppLogger().Warn("sync-info 调用失败",
							zap.Uint("device_id", id),
							zap.Error(syncErr))
					}
				}
			}
		}

		return s.GetRealtimeStatus(ctx, "device", id)

	default:
		return nil, errors.New(errors.CodeInvalidParam, "不支持的资产类型，仅支持 card 或 device")
	}
}

// updateDeviceFromSyncInfo 根据 Gateway sync-info 响应更新设备状态字段和当前卡标识
// 失败时只记录日志，不返回错误（非关键步骤）
func (s *Service) updateDeviceFromSyncInfo(ctx context.Context, deviceID uint, resp *gateway.SyncDeviceInfoResp) {
	now := time.Now()

	// 解析 LastOnlineTime（ISO 8601 字符串 → *time.Time）
	var lastOnlineTime *time.Time
	if resp.LastOnlineTime != "" {
		if t, err := time.Parse(time.RFC3339, resp.LastOnlineTime); err == nil {
			lastOnlineTime = &t
		}
	}

	// 更新设备 5 个存储字段
	updates := map[string]any{
		"online_status":        resp.OnlineStatus,
		"software_version":     resp.SoftwareVersion,
		"switch_mode":          resp.SwitchMode,
		"last_gateway_sync_at": now,
	}
	if lastOnlineTime != nil {
		updates["last_online_time"] = lastOnlineTime
	}

	if err := s.db.WithContext(ctx).
		Model(&model.Device{}).
		Where("id = ?", deviceID).
		Updates(updates).Error; err != nil {
		logger.GetAppLogger().Warn("sync-info 更新设备字段失败",
			zap.Uint("device_id", deviceID),
			zap.Error(err))
		return
	}

	// 更新 is_current 标识（事务原子操作，per D-14 决策）
	if err := s.deviceSimBindingStore.UpdateIsCurrentByDeviceID(ctx, deviceID, resp.CurrentIccid); err != nil {
		logger.GetAppLogger().Warn("sync-info 更新 is_current 失败",
			zap.Uint("device_id", deviceID),
			zap.Error(err))
	}
}

// GetPackages 获取资产的所有套餐列表（支持分页）
// page 默认 1，pageSize 默认 50，pageSize 最大 100
func (s *Service) GetPackages(ctx context.Context, assetType string, id uint, page, pageSize int) (*dto.AssetPackagesResult, error) {
	// 分页参数边界处理
	if page < 1 {
		page = 1
	}
	if pageSize < 1 {
		pageSize = 50
	}
	if pageSize > 100 {
		pageSize = 100
	}

	// assetType 对应 Store 中的 carrierType：card→iot_card, device→device
	carrierType := assetType
	if assetType == "card" {
		carrierType = "iot_card"
	}

	usages, err := s.packageUsageStore.ListByCarrier(ctx, carrierType, id)
	if err != nil {
		return nil, errors.Wrap(errors.CodeInternalError, err, "查询套餐使用记录失败")
	}

	// 收集所有 PackageID 并批量查询
	pkgIDSet := make(map[uint]struct{}, len(usages))
	for _, u := range usages {
		pkgIDSet[u.PackageID] = struct{}{}
	}
	pkgIDs := make([]uint, 0, len(pkgIDSet))
	for id := range pkgIDSet {
		pkgIDs = append(pkgIDs, id)
	}
	packages, pkgErr := s.packageStore.GetByIDsUnscoped(ctx, pkgIDs)
	if pkgErr != nil {
		logger.GetAppLogger().Warn("批量查询套餐信息失败，套餐名称可能缺失",
			zap.Uints("package_ids", pkgIDs),
			zap.Error(pkgErr))
	}
	pkgMap := make(map[uint]*model.Package, len(packages))
	for _, p := range packages {
		pkgMap[p.ID] = p
	}

	all := make([]*dto.AssetPackageResponse, 0, len(usages))
	for _, u := range usages {
		pkg := pkgMap[u.PackageID]
		ratio := 1.0
		pkgName := ""
		pkgType := ""
		if pkg != nil {
			ratio = safeVirtualRatio(pkg.VirtualRatio)
			pkgName = pkg.PackageName
			pkgType = pkg.PackageType
		}

		item := &dto.AssetPackageResponse{
			PackageUsageID:  u.ID,
			PackageID:       u.PackageID,
			PackageName:     pkgName,
			PackageType:     pkgType,
			UsageType:       u.UsageType,
			Status:          u.Status,
			StatusName:      packageStatusName(u.Status),
			DataLimitMB:     u.DataLimitMB,
			VirtualLimitMB:  int64(float64(u.DataLimitMB) / ratio),
			DataUsageMB:     u.DataUsageMB,
			VirtualUsedMB:   float64(u.DataUsageMB) / ratio,
			VirtualRemainMB: float64(u.DataLimitMB-u.DataUsageMB) / ratio,
			VirtualRatio:    ratio,
			ActivatedAt:     nonZeroTimePtr(u.ActivatedAt),
			ExpiresAt:       nonZeroTimePtr(u.ExpiresAt),
			MasterUsageID:   u.MasterUsageID,
			Priority:        u.Priority,
			CreatedAt:       u.CreatedAt,
		}
		all = append(all, item)
	}

	// 按 created_at DESC 排序
	sort.Slice(all, func(i, j int) bool {
		return all[i].CreatedAt.After(all[j].CreatedAt)
	})

	total := int64(len(all))
	offset := (page - 1) * pageSize
	end := offset + pageSize
	if offset >= len(all) {
		offset = len(all)
	}
	if end > len(all) {
		end = len(all)
	}
	items := all[offset:end]

	return &dto.AssetPackagesResult{
		Total:    total,
		Page:     page,
		PageSize: pageSize,
		Items:    items,
	}, nil
}

// GetCurrentPackage 获取资产当前生效的主套餐
func (s *Service) GetCurrentPackage(ctx context.Context, assetType string, id uint) (*dto.AssetPackageResponse, error) {
	carrierType := assetType
	if assetType == "card" {
		carrierType = "iot_card"
	}

	usage, err := s.packageUsageStore.GetActiveMainPackage(ctx, carrierType, id)
	if err != nil {
		// 记录不存在表示当前无生效套餐，属于正常业务状态，返回 nil 而非错误
		// 其他 DB 错误才作为服务端错误处理
		if stderrors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil
		}
		return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询当前生效套餐失败")
	}

	pkg, pkgErr := s.packageStore.GetByID(ctx, usage.PackageID)
	ratio := 1.0
	pkgName := ""
	pkgType := ""
	if pkgErr == nil && pkg != nil {
		ratio = safeVirtualRatio(pkg.VirtualRatio)
		pkgName = pkg.PackageName
		pkgType = pkg.PackageType
	}

	return &dto.AssetPackageResponse{
		PackageUsageID:  usage.ID,
		PackageID:       usage.PackageID,
		PackageName:     pkgName,
		PackageType:     pkgType,
		UsageType:       usage.UsageType,
		Status:          usage.Status,
		StatusName:      packageStatusName(usage.Status),
		DataLimitMB:     usage.DataLimitMB,
		VirtualLimitMB:  int64(float64(usage.DataLimitMB) / ratio),
		DataUsageMB:     usage.DataUsageMB,
		VirtualUsedMB:   float64(usage.DataUsageMB) / ratio,
		VirtualRemainMB: float64(usage.DataLimitMB-usage.DataUsageMB) / ratio,
		VirtualRatio:    ratio,
		ActivatedAt:     nonZeroTimePtr(usage.ActivatedAt),
		ExpiresAt:       nonZeroTimePtr(usage.ExpiresAt),
		MasterUsageID:   usage.MasterUsageID,
		Priority:        usage.Priority,
		CreatedAt:       usage.CreatedAt,
	}, nil
}

// getDeviceProtectStatus 查询设备保护期状态
func (s *Service) getDeviceProtectStatus(ctx context.Context, deviceID uint) string {
	stopKey := constants.RedisDeviceProtectKey(deviceID, "stop")
	startKey := constants.RedisDeviceProtectKey(deviceID, "start")
	if s.redis.Exists(ctx, stopKey).Val() > 0 {
		return "stop"
	}
	if s.redis.Exists(ctx, startKey).Val() > 0 {
		return "start"
	}
	return "none"
}

// nonZeroTimePtr 将非零时间转为指针，零值返回 nil（避免序列化出历史时区偏移 +08:05）
func nonZeroTimePtr(t time.Time) *time.Time {
	if t.IsZero() {
		return nil
	}
	return &t
}

// safeVirtualRatio 安全获取虚流量比例，避免除零
func safeVirtualRatio(ratio float64) float64 {
	if ratio <= 0 {
		return 1.0
	}
	return ratio
}

// packageStatusName 套餐状态码转中文名称
func packageStatusName(status int) string {
	switch status {
	case 0:
		return "待生效"
	case 1:
		return "生效中"
	case 2:
		return "已用完"
	case 3:
		return "已过期"
	case 4:
		return "已失效"
	default:
		return "未知"
	}
}