package packagepkg

import (
	"context"
	"strconv"
	"time"

	"gorm.io/gorm"

	priorityapp "github.com/break/junhong_cmp_fiber/internal/application/prioritypolling"
	"github.com/break/junhong_cmp_fiber/internal/model"
	"github.com/break/junhong_cmp_fiber/pkg/constants"
	"github.com/break/junhong_cmp_fiber/pkg/errors"
)

// 本文件集中承载卡轮询优先队列在套餐域的两个判定与两条可靠事件写入：
// 生效触发（新购/续购/加油包/排队顺延）与「资产无有效套餐」触发。
// 事件 ID 命名空间与载荷形状只在本文件构造，调用点不得各自拼装，避免同一决策出现多份实现。

// ResolveActivationTriggerType 判定主套餐本次生效属于新购还是续购。
// 依据是该载体在本次生效前是否存在更早的套餐使用记录，而不是当前是否存在在用主套餐：
// 过期后续购时已无在用主套餐，用「当前在用」判定会误判为新购。
func ResolveActivationTriggerType(ctx context.Context, tx *gorm.DB, carrierType string, carrierID, usageID uint) (string, error) {
	hasEarlier, err := HasEarlierPackageUsage(ctx, tx, carrierType, carrierID, usageID)
	if err != nil {
		return "", err
	}
	if hasEarlier {
		return constants.PollingPriorityTriggerRenewalActivated, nil
	}
	return constants.PollingPriorityTriggerPurchaseActivated, nil
}

// HasEarlierPackageUsage 判断该载体在本次生效前是否已存在更早的套餐使用记录。
// 查询与本次记录同载体，并排除本次记录自身。
func HasEarlierPackageUsage(ctx context.Context, tx *gorm.DB, carrierType string, carrierID, excludeUsageID uint) (bool, error) {
	if tx == nil || carrierID == 0 {
		return false, errors.New(errors.CodeInvalidParam, "查询更早套餐使用记录缺少载体")
	}
	query, err := filterPackageUsageByCarrier(tx.WithContext(ctx).Model(&model.PackageUsage{}), carrierType, carrierID)
	if err != nil {
		return false, err
	}
	if excludeUsageID != 0 {
		query = query.Where("id <> ?", excludeUsageID)
	}
	var count int64
	if err := query.Count(&count).Error; err != nil {
		return false, errors.Wrap(errors.CodeDatabaseError, err, "查询更早套餐使用记录失败")
	}
	return count > 0, nil
}

// HasPendingPackageUsage 判断该载体是否存在待生效的套餐使用记录。
//
// 这是「资产无有效套餐」场景触发优先轮询的前置条件：没有待同步的生效业务时，
// 每个普通套餐轮询周期都重新入队只会形成自激循环，因此必须以此条件收敛。
func HasPendingPackageUsage(ctx context.Context, tx *gorm.DB, carrierType string, carrierID uint) (bool, error) {
	if tx == nil || carrierID == 0 {
		return false, errors.New(errors.CodeInvalidParam, "查询待生效套餐使用记录缺少载体")
	}
	query, err := filterPackageUsageByCarrier(tx.WithContext(ctx).Model(&model.PackageUsage{}), carrierType, carrierID)
	if err != nil {
		return false, err
	}
	var count int64
	if err := query.Where("status = ?", constants.PackageUsageStatusPending).Count(&count).Error; err != nil {
		return false, errors.Wrap(errors.CodeDatabaseError, err, "查询待生效套餐使用记录失败")
	}
	return count > 0, nil
}

// AppendActivatedPriorityRequested 在套餐生效事务内追加「套餐生效」优先轮询请求。
//
// triggerType 只接受 purchase_activated/renewal_activated/queue_activated/addon_activated；
// 调用点必须传入生效状态分支所在的业务事务，禁止在事务提交后另行投递。
func AppendActivatedPriorityRequested(
	ctx context.Context,
	tx *gorm.DB,
	writer priorityapp.PriorityEventWriter,
	usage *model.PackageUsage,
	carrierType string,
	carrierID uint,
	triggerType string,
	occurredAt time.Time,
) error {
	if writer == nil {
		return errors.New(errors.CodeInternalError, "优先轮询 Outbox Writer 未配置")
	}
	if usage == nil || usage.ID == 0 || carrierID == 0 {
		return errors.New(errors.CodeInvalidParam, "优先轮询事件缺少套餐使用记录或载体")
	}
	// 事件 ID 只承担「全局唯一 + 重投稳定」：触发类型与来源已写入事件载荷与事实行，不再重复编码，
	// 以把长度压进预算（见 constants.PollingPriorityEventKeyPrefix 的长度说明）。
	// 一条套餐使用记录的生效是单向一次性事实，因此 usage ID 本身即唯一键。
	eventID := constants.PollingPriorityEventKeyPrefix + "usage:" + strconv.FormatUint(uint64(usage.ID), 10)
	return writer.AppendPriorityRequested(ctx, tx, priorityapp.PriorityRequestedEvent{
		EventID:              eventID,
		ResourceType:         carrierType,
		ResourceID:           carrierID,
		TriggerType:          triggerType,
		SourceOrderID:        usage.OrderID,
		SourcePackageUsageID: usage.ID,
		OccurredAt:           occurredAt,
		RequestID:            eventID,
		CorrelationID:        eventID,
	})
}

// AppendNoValidPackagePriorityRequested 在触发事务内追加「资产无有效套餐」优先轮询请求。
//
// 事件 ID 以秒级时间戳结尾：本场景在待同步业务持续存在时每个普通套餐周期重复触发，
// 稳定键会让第二次触发起被 Outbox 去重而永久失效（如优先项已终态出队后将无法再次加急），
// 而同一秒内的并发重复触发共享一个事件，等价于同一轮询周期的合并。
func AppendNoValidPackagePriorityRequested(
	ctx context.Context,
	tx *gorm.DB,
	writer priorityapp.PriorityEventWriter,
	carrierType string,
	carrierID uint,
	occurredAt time.Time,
) error {
	if writer == nil {
		return errors.New(errors.CodeInternalError, "优先轮询 Outbox Writer 未配置")
	}
	if carrierID == 0 {
		return errors.New(errors.CodeInvalidParam, "优先轮询事件缺少载体")
	}
	// 载体类型压缩为单字母代码（c-iot_card d-device）：完整载体类型与资源 ID 已随事件载体与载荷传递，
	// 此处只为把长度压进预算（见 constants.PollingPriorityEventKeyPrefix 的长度说明）。
	eventID := constants.PollingPriorityEventKeyPrefix + "nvp:" + pollingPriorityCarrierCode(carrierType) + ":" +
		strconv.FormatUint(uint64(carrierID), 10) + ":" + strconv.FormatInt(occurredAt.Unix(), 10)
	return writer.AppendPriorityRequested(ctx, tx, priorityapp.PriorityRequestedEvent{
		EventID:       eventID,
		ResourceType:  carrierType,
		ResourceID:    carrierID,
		TriggerType:   constants.PollingPriorityTriggerNoValidPackage,
		OccurredAt:    occurredAt,
		RequestID:     eventID,
		CorrelationID: eventID,
	})
}

// pollingPriorityCarrierCode 把载体类型压缩为事件 ID 中使用的单字母代码。
func pollingPriorityCarrierCode(carrierType string) string {
	if carrierType == constants.AssetTypeDevice {
		return "d"
	}
	return "c"
}

// filterPackageUsageByCarrier 按载体类型过滤套餐使用记录。
// 载体口径与卡的有效套餐判定一致：device 查设备载体，iot_card 查卡载体。
func filterPackageUsageByCarrier(query *gorm.DB, carrierType string, carrierID uint) (*gorm.DB, error) {
	switch carrierType {
	case constants.AssetTypeDevice:
		return query.Where("device_id = ?", carrierID), nil
	case constants.AssetTypeIotCard:
		return query.Where("iot_card_id = ?", carrierID), nil
	default:
		return nil, errors.New(errors.CodeInvalidParam, "不支持的套餐载体类型：只接受 iot_card 或 device")
	}
}