// Package packageexpiry 提供资产主套餐最终到期时间的统一只读推算。
package packageexpiry

import (
	"context"
	"sort"
	"time"

	packagedomain "github.com/break/junhong_cmp_fiber/internal/domain/package"
	"github.com/break/junhong_cmp_fiber/internal/model"
	"github.com/break/junhong_cmp_fiber/internal/model/dto"
	packagepkg "github.com/break/junhong_cmp_fiber/internal/service/package"
	"github.com/break/junhong_cmp_fiber/pkg/constants"
	"github.com/break/junhong_cmp_fiber/pkg/errors"
	"gorm.io/gorm"
)

var shanghaiLocation = time.FixedZone("Asia/Shanghai", 8*60*60)

// Query 查询单个或批量资产的套餐最终到期时间。
type Query struct {
	db  *gorm.DB
	now func() time.Time
}

// NewQuery 创建套餐最终到期查询。
func NewQuery(db *gorm.DB) *Query {
	return &Query{db: db, now: time.Now}
}

// Resolve 查询单个资产的最终到期推算结果。
func (q *Query) Resolve(ctx context.Context, assetType string, assetID uint) (dto.PackageExpiryEstimate, error) {
	results, err := q.ResolveBatch(ctx, assetType, []uint{assetID})
	if err != nil {
		return dto.PackageExpiryEstimate{}, err
	}
	return results[assetID], nil
}

// ResolveBatch 批量查询同类型资产的最终到期推算结果，避免列表场景逐资产读取。
func (q *Query) ResolveBatch(ctx context.Context, assetType string, assetIDs []uint) (map[uint]dto.PackageExpiryEstimate, error) {
	results := make(map[uint]dto.PackageExpiryEstimate, len(assetIDs))
	if len(assetIDs) == 0 {
		return results, nil
	}
	column, ok := packageUsageAssetColumn(assetType)
	if !ok {
		return nil, errors.New(errors.CodeInvalidParam, "资产类型无效")
	}
	usages := make([]*model.PackageUsage, 0)
	if err := q.db.WithContext(ctx).
		Where(column+" IN ?", assetIDs).
		Where("master_usage_id IS NULL").
		Where("status IN ?", []int{constants.PackageUsageStatusPending, constants.PackageUsageStatusActive, constants.PackageUsageStatusDepleted}).
		Where("refund_id IS NULL").
		Order("priority ASC, created_at ASC, id ASC").
		Find(&usages).Error; err != nil {
		return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询套餐最终到期记录失败")
	}

	packages, err := q.loadFallbackPackages(ctx, usages)
	if err != nil {
		return nil, err
	}
	grouped := make(map[uint][]*model.PackageUsage, len(assetIDs))
	for _, usage := range usages {
		assetID := usage.IotCardID
		if assetType == constants.AssetTypeDevice {
			assetID = usage.DeviceID
		}
		grouped[assetID] = append(grouped[assetID], usage)
	}
	for _, assetID := range assetIDs {
		results[assetID] = Calculate(grouped[assetID], packages, q.now())
	}
	return results, nil
}

func (q *Query) loadFallbackPackages(ctx context.Context, usages []*model.PackageUsage) (map[uint]*model.Package, error) {
	ids := make([]uint, 0)
	seen := make(map[uint]struct{})
	for _, usage := range usages {
		if !isEmptyHistoricalTerms(usage) {
			continue
		}
		if _, exists := seen[usage.PackageID]; !exists {
			seen[usage.PackageID] = struct{}{}
			ids = append(ids, usage.PackageID)
		}
	}
	packages := make(map[uint]*model.Package, len(ids))
	if len(ids) == 0 {
		return packages, nil
	}
	var rows []*model.Package
	if err := q.db.WithContext(ctx).Where("id IN ?", ids).Find(&rows).Error; err != nil {
		return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询历史套餐计时条款失败")
	}
	for _, pkg := range rows {
		packages[pkg.ID] = pkg
	}
	return packages, nil
}

// Calculate 使用已批量读取的记录和历史套餐回退数据计算最终到期时间。
func Calculate(usages []*model.PackageUsage, packages map[uint]*model.Package, now time.Time) dto.PackageExpiryEstimate {
	eligible := make([]*model.PackageUsage, 0, len(usages))
	for _, usage := range usages {
		if usage == nil || usage.DeletedAt.Valid || usage.RefundID != nil || usage.MasterUsageID != nil {
			continue
		}
		if usage.Status == constants.PackageUsageStatusPending || usage.Status == constants.PackageUsageStatusActive || usage.Status == constants.PackageUsageStatusDepleted {
			eligible = append(eligible, usage)
		}
	}
	if len(eligible) == 0 {
		return newEstimate(constants.PackageExpiryEstimateStatusNone, nil, now)
	}
	sort.SliceStable(eligible, func(i, j int) bool {
		if eligible[i].Priority != eligible[j].Priority {
			return eligible[i].Priority < eligible[j].Priority
		}
		if !eligible[i].CreatedAt.Equal(eligible[j].CreatedAt) {
			return eligible[i].CreatedAt.Before(eligible[j].CreatedAt)
		}
		return eligible[i].ID < eligible[j].ID
	})

	currentIndex := -1
	for i, usage := range eligible {
		if usage.Status == constants.PackageUsageStatusActive || usage.Status == constants.PackageUsageStatusDepleted {
			if currentIndex >= 0 || usage.ExpiresAt == nil {
				return newEstimate(constants.PackageExpiryEstimateStatusInvalidData, nil, now)
			}
			currentIndex = i
		}
	}
	if currentIndex < 0 {
		first := eligible[0]
		terms, ok := resolveTerms(first, packages)
		if !ok {
			return newEstimate(constants.PackageExpiryEstimateStatusInvalidData, nil, now)
		}
		if first.PendingRealnameActivation || terms.ExpiryBase == constants.PackageExpiryBaseFromActivation {
			return newEstimate(constants.PackageExpiryEstimateStatusWaitingActivation, nil, now)
		}
		return newEstimate(constants.PackageExpiryEstimateStatusInvalidData, nil, now)
	}
	for i := 0; i < currentIndex; i++ {
		if eligible[i].Status == constants.PackageUsageStatusPending {
			return newEstimate(constants.PackageExpiryEstimateStatusInvalidData, nil, now)
		}
	}
	cursor := eligible[currentIndex].ExpiresAt.In(shanghaiLocation)
	for _, usage := range eligible[currentIndex+1:] {
		if usage.Status != constants.PackageUsageStatusPending {
			return newEstimate(constants.PackageExpiryEstimateStatusInvalidData, nil, now)
		}
		terms, ok := resolveTerms(usage, packages)
		if !ok {
			return newEstimate(constants.PackageExpiryEstimateStatusInvalidData, nil, now)
		}
		start := cursor.Add(time.Second)
		cursor = packagepkg.CalculateExpiryTime(terms.CalendarType, start, terms.DurationMonths, terms.DurationDays).In(shanghaiLocation)
	}
	return newEstimate(constants.PackageExpiryEstimateStatusExact, &cursor, now)
}

func resolveTerms(usage *model.PackageUsage, packages map[uint]*model.Package) (packagedomain.TermsSnapshot, bool) {
	terms := packagedomain.TermsSnapshotFromUsage(usage)
	if terms.IsValid() {
		return terms, true
	}
	if !isEmptyHistoricalTerms(usage) {
		return packagedomain.TermsSnapshot{}, false
	}
	pkg := packages[usage.PackageID]
	terms, err := packagedomain.ResolveTermsSnapshot(pkg, nil)
	return terms, err == nil
}

func isEmptyHistoricalTerms(usage *model.PackageUsage) bool {
	// UR55 的 000163 迁移已在测试环境生效：触发器拒绝新记录写入空快照，
	// 因此整组空值只可能是迁移前遗留记录；任意部分空值仍按异常处理。
	return usage.ExpiryBaseSnapshot == "" && usage.CalendarTypeSnapshot == "" && usage.DurationMonthsSnapshot == 0 && usage.DurationDaysSnapshot == 0
}

func packageUsageAssetColumn(assetType string) (string, bool) {
	switch assetType {
	case constants.AssetTypeIotCard, constants.AssetResolveTypeCard:
		return "iot_card_id", true
	case constants.AssetTypeDevice:
		return "device_id", true
	default:
		return "", false
	}
}

func newEstimate(status string, expiresAt *time.Time, now time.Time) dto.PackageExpiryEstimate {
	result := dto.PackageExpiryEstimate{ExpiryEstimateStatus: status, ExpiryEstimateStatusName: constants.GetPackageExpiryEstimateStatusName(status)}
	if status != constants.PackageExpiryEstimateStatusExact || expiresAt == nil {
		return result
	}
	days := dateInShanghai(*expiresAt).Sub(dateInShanghai(now))
	daysUntil := int(days.Hours() / 24)
	result.EstimatedFinalExpiresAt = expiresAt
	result.DaysUntilFinalExpiry = &daysUntil
	result.IsExpiring = daysUntil >= 0 && daysUntil <= 15
	return result
}

func dateInShanghai(value time.Time) time.Time {
	local := value.In(shanghaiLocation)
	return time.Date(local.Year(), local.Month(), local.Day(), 0, 0, 0, 0, shanghaiLocation)
}