productcatalog

var DynamicPriceDefaultMultiplier = decimal.NewFromFloat(1)

var ErrAddonHasNoRateCards = models.NewValidationIssue(
	ErrCodeAddonHasNoRateCards,
	"add-on must have at least one rate card",
	models.WithFieldString("rateCards"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrAddonInvalidInstanceType = models.NewValidationIssue(
	ErrCodeAddonInvalidInstanceType,
	"invalid instance type",
	models.WithFieldString("instanceType"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrAddonInvalidPriceForMultiInstance = models.NewValidationIssue(
	ErrCodeAddonInvalidPriceForMultiInstance,
	"only free or flat price ratecards are allowed for add-on with multiple instance type",
	models.WithFieldString("price"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrAddonInvalidStatus = models.NewValidationIssue(
	ErrCodeAddonInvalidStatus,
	"invalid status",
	models.WithFieldString("status"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrAddonInvalidStatusForPublish = models.NewValidationIssue(
	ErrCodeAddonInvalidStatusForPublish,
	"only draft add-ons can be published",
	models.WithFieldString("status"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrAddonKeyEmpty = models.NewValidationIssue(
	ErrCodeAddonKeyEmpty,
	"key must not be empty",
	models.WithFieldString("key"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrAddonNameEmpty = models.NewValidationIssue(
	ErrCodeAddonNameEmpty,
	"name must not be empty",
	models.WithFieldString("name"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrAddonRateCardUnitConfigMismatch = models.NewValidationIssue(
	ErrCodeAddonRateCardUnitConfigMismatch,
	"unit config must match",
	models.WithFieldString("unitConfig"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrBillingCadenceInvalidValue = models.NewValidationIssue(
	ErrCodeBillingCadenceInvalidValue,
	"billing cadence must be positive and 1 hour long duration at least",
	models.WithFieldString("billingCadence"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrCurrencyInvalid = models.NewValidationIssue(
	ErrCodeCurrencyInvalid,
	"currency is invalid",
	models.WithFieldString("currency"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrDeprecatedUnalignedSubscription = models.NewValidationIssue(
	ErrCodeDeprecatedUnalignedSubscription,
	"unaligned subscriptions are being deprecated",
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrEffectivePeriodFromAfterTo = models.NewValidationIssue(
	ErrCodeEffectivePeriodFromAfterTo,
	"effectiveFrom is after effectiveTo",
	models.WithFieldString("effectiveFrom"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrEffectivePeriodFromNotSet = models.NewValidationIssue(
	ErrCodeEffectivePeriodFromNotSet,
	"effectiveFrom is must be provided if effectiveTo is set",
	models.WithFieldString("effectiveFrom"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrEntitlementTemplateInvalidIssueAfterResetWithPriority = models.NewValidationIssue(
	ErrCodeEntitlementTemplateInvalidIssueAfterResetWithPriority,
	"invalid entitlement template as issue after reset is required if issue after reset priority is set",
	models.WithFieldString("issueAfterReset"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrEntitlementTemplateInvalidJSONConfig = models.NewValidationIssue(
	ErrCodeEntitlementTemplateInvalidJSONConfig,
	"invalid JSON in static entitlement config",
	models.WithFieldString("entitlementTemplate", "config"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrEntitlementTemplateIssueAfterResetRequired = models.NewValidationIssue(
	ErrCodeEntitlementTemplateIssueAfterResetRequired,
	"issueAfterReset is required for metered entitlement templates",
	models.WithFieldString("entitlementTemplate", "issueAfterReset"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrEntitlementTemplateNegativeUsagePeriod = models.NewValidationIssue(
	ErrCodeEntitlementTemplateNegativeUsagePeriod,
	"usage period must be positive",
	models.WithFieldString("usagePeriod"),
	models.WithWarningSeverity(),
)

var ErrEntitlementTemplateUsagePeriodLessThenAnHour = models.NewValidationIssue(
	ErrCodeEntitlementTemplateUsagePeriodLessThenAnHour,
	"usage period must be at least 1 hour",
	models.WithFieldString("usagePeriod"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrIDEmpty = models.NewValidationIssue(
	ErrCodeIDEmpty,
	"id must not be empty",
	models.WithFieldString("id"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrNamespaceEmpty = models.NewValidationIssue(
	ErrCodeNamespaceEmpty,
	"namespace must not be empty",
	models.WithFieldString("namespace"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrPercentageDiscountInvalidValue = models.NewValidationIssue(
	ErrCodePercentageDiscountInvalidValue,
	"percentage must be between 0 and 100",
	models.WithFieldString("percentage"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrPlanAddonCurrencyMismatch = models.NewValidationIssue(
	ErrCodePlanAddonCurrencyMismatch,
	"currency of the plan and addon must match",
	models.WithFieldString("currency"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrPlanAddonIncompatibleStatus = models.NewValidationIssue(
	ErrCodePlanAddonIncompatibleStatus,
	"plan status is incompatible with the addon status",
	models.WithFieldString("status"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrPlanAddonMaxQuantityMustBeSet = models.NewValidationIssue(
	ErrCodePlanAddonMaxQuantityMustBeSet,
	"maximum quantity, when set, must be a positive integer for add-ons with multiple instance type",
	models.WithFieldString("maxQuantity"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrPlanAddonMaxQuantityMustNotBeSet = models.NewValidationIssue(
	ErrCodePlanAddonMaxQuantityMustNotBeSet,
	"maximum quantity must not be set for add-on with single instance type",
	models.WithFieldString("maxQuantity"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrPlanAddonUnknownPlanPhaseKey = models.NewValidationIssue(
	ErrCodePlanAddonUnknownPlanPhaseKey,
	"add-on must define valid/existing plan phase key from which the add-on is available for purchase",
	models.WithFieldString("fromPlanPhase"),
	models.WithWarningSeverity(),
)

var ErrPlanBillingCadenceAllowedValues = []datetime.ISODurationString{
	"P1W",
	"P2W",
	"P4W",
	"P1M",
	"P3M",
	"P6M",
	"P12M",
	"P1Y",
}

var ErrPlanBillingCadenceInvalid = models.NewValidationIssue(
	ErrCodePlanBillingCadenceInvalid,
	fmt.Sprintf("billing cadence must be one of the following: %s", strings.Join(lo.Map(ErrPlanBillingCadenceAllowedValues, func(v datetime.ISODurationString, _ int) string { return v.String() }), ", ")),
	models.WithFieldString("billingCadence"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrPlanBillingCadenceNotCompatible = models.NewValidationIssue(
	ErrCodePlanBillingCadenceNotCompatible,
	"plan billing cadence is not compatible with rate card billing cadence",
	models.WithFieldString("billingCadence"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrPlanHasIncompatibleAddon = models.NewValidationIssue(
	ErrCodePlanHasIncompatibleAddon,
	"plan has incompatible add-on assignment",
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrPlanHasLastPhaseWithDuration = models.NewValidationIssue(
	ErrCodePlanHasLastPhaseWithDuration,
	"duration must not be set for the last plan phase",
	models.WithFieldString("duration"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrPlanHasNonLastPhaseWithNoDuration = models.NewValidationIssue(
	ErrCodePlanHasNonLastPhaseWithNoDuration,
	"duration must be set for plan phase if it is not the last one",
	models.WithFieldString("duration"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrPlanInvalidStatus = models.NewValidationIssue(
	ErrCodePlanInvalidStatus,
	"invalid status",
	models.WithFieldString("status"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrPlanPhaseDuplicatedKey = models.NewValidationIssue(
	ErrCodePlanPhaseDuplicatedKey,
	"duplicated key",
	models.WithFieldString("key"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrPlanPhaseDurationLessThenAnHour = models.NewValidationIssue(
	ErrCodePlanPhaseDurationLessThenAnHour,
	"duration must be at least 1 hour",
	models.WithFieldString("duration"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrPlanPhaseHasNoRateCards = models.NewValidationIssue(
	ErrCodePlanPhaseHasNoRateCards,
	"plan phase must have at least one rate card",
	models.WithFieldString("rateCards"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrPlanPhaseWithNegativeDuration = models.NewValidationIssue(
	ErrCodePlanPhaseWithNegativeDuration,
	"duration must be positive",
	models.WithFieldString("duration"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrPlanWithNoPhases = models.NewValidationIssue(
	ErrCodePlanWithNoPhases,
	"plan must have at least one phase",
	models.WithFieldString("phases"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrRateCardBillingCadenceMismatch = models.NewValidationIssue(
	ErrCodeRateCardBillingCadenceMismatch,
	"billing cadence must match",
	models.WithFieldString("billingCadence"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrRateCardBillingCadenceUnaligned = models.NewValidationIssue(
	ErrCodeRateCardBillingCadenceUnaligned,
	"ratecards with prices must have compatible billing cadence",
	models.WithFieldString("billingCadence"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrRateCardDuplicatedKey = models.NewValidationIssue(
	ErrCodeRateCardDuplicatedKey,
	"duplicated key",
	models.WithFieldString("key"),
	models.WithCriticalSeverity(),
)

var ErrRateCardEntitlementTemplateTypeMismatch = models.NewValidationIssue(
	ErrCodeRateCardEntitlementTemplateTypeMismatch,
	"entitlement template type must match",
	models.WithFieldString("type"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrRateCardEntitlementTemplateWithNoFeature = models.NewValidationIssue(
	ErrCodeRateCardEntitlementTemplateWithNoFeature,
	"entitlement template requires feature to be associated with",
	models.WithFieldString("featureKey"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrRateCardFeatureArchived = models.NewValidationIssue(
	ErrCodeRateCardFeatureArchived,
	"feature archived",
	models.WithFieldString("featureKey"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrRateCardFeatureIDMismatch = models.NewValidationIssue(
	ErrCodeRateCardFeatureIDMismatch,
	"feature identifiers id must match",
	models.WithFieldString("featureId"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrRateCardFeatureKeyMismatch = models.NewValidationIssue(
	ErrCodeRateCardFeatureKeyMismatch,
	"feature key must match",
	models.WithFieldString("featureKey"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrRateCardFeatureMismatch = models.NewValidationIssue(
	ErrCodeRateCardFeatureMismatch,
	"feature id and key must reference the same feature",
	models.WithFieldString("featureKey"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrRateCardFeatureNotFound = models.NewValidationIssue(
	ErrCodeRateCardFeatureNotFound,
	"feature not found",
	models.WithFieldString("featureKey"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrRateCardKeyFeatureKeyMismatch = models.NewValidationIssue(
	ErrCodeRateCardKeyFeatureKeyMismatch,
	"rate card key must match feature key",
	models.WithFieldString("key"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrRateCardKeyMismatch = models.NewValidationIssue(
	ErrCodeRateCardKeyMismatch,
	"key must match",
	models.WithFieldString("key"),
	models.WithWarningSeverity(),
)

var ErrRateCardMeteredEntitlementTemplateUsagePeriodMismatch = models.NewValidationIssue(
	ErrCodeRateCardMeteredEntitlementTemplateUsagePeriodMismatch,
	"usage period for metered entitlement template must match",
	models.WithFieldString("usagePeriod"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrRateCardMultipleBillingCadence = models.NewValidationIssue(
	ErrCodeRateCardMultipleBillingCadence,
	"ratecards with prices must have the exact same billing cadence",
	models.WithFieldString("billingCadence"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrRateCardOnlyFlatPriceAllowed = models.NewValidationIssue(
	ErrCodeRateCardOnlyFlatPriceAllowed,
	"only flat price is allowed",
	models.WithFieldString("price"),
	models.WithWarningSeverity(),
)

var ErrRateCardPercentageDiscountNotAllowed = models.NewValidationIssue(
	ErrCodeRateCardPercentageDiscountNotAllowed,
	"percentage discount is not allowed",
	models.WithFieldString("percentage"),
	models.WithWarningSeverity(),
)

var ErrRateCardPricePaymentTermMismatch = models.NewValidationIssue(
	ErrCodeRateCardPricePaymentTermMismatch,
	"price payment term must match",
	models.WithFieldString("price"),
	models.WithWarningSeverity(),
)

var ErrRateCardPriceTypeMismatch = models.NewValidationIssue(
	ErrCodeRateCardPriceTypeMismatch,
	"price type must match",
	models.WithFieldString("price"),
	models.WithWarningSeverity(),
)

var ErrRateCardStaticEntitlementTemplateNotAllowed = models.NewValidationIssue(
	ErrCodeRateCardStaticEntitlementTemplateNotAllowed,
	"static entitlement template is not allowed",
	models.WithFieldString("type"),
	models.WithWarningSeverity(),
)

var ErrRateCardUnitConfigRequiresUsageBasedPrice = models.NewValidationIssue(
	ErrCodeRateCardUnitConfigRequiresUsageBasedPrice,
	"unit config requires a usage-based price (unit, graduated, or volume)",
	models.WithFieldString("unit_config"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrRateCardUsageBasedPriceWithFeatureAndNoMeter = models.NewValidationIssue(
	ErrCodeRateCardUsageBasedPriceWithFeatureAndNoMeter,
	"usage-based price requires feature with meter to be associated with",
	models.WithFieldString("featureKey"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrRateCardUsageBasedPriceWithNoFeature = models.NewValidationIssue(
	ErrCodeRateCardUsageBasedPriceWithNoFeature,
	"usage-based price requires feature to be associated with",
	models.WithFieldString("featureKey"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrResourceKeyEmpty = models.NewValidationIssue(
	ErrCodeResourceKeyEmpty,
	"key must not be empty",
	models.WithFieldString("key"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrResourceNameEmpty = models.NewValidationIssue(
	ErrCodeResourceNameEmpty,
	"name must not be empty",
	models.WithFieldString("name"),
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrUnitConfigNotRepresentable = models.NewValidationIssue(
	ErrCodeUnitConfigNotRepresentable,
	"this resource uses unit_config and is only available via the v3 API",
	models.WithCriticalSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrUsageDiscountNegativeQuantity = models.NewValidationIssue(
	ErrCodeUsageDiscountNegativeQuantity,
	"usage must be greater than 0",
	models.WithFieldString("quantity"),
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ErrUsageDiscountWithFlatPrice = models.NewValidationIssue(
	ErrCodeUsageDiscountWithFlatPrice,
	"usage discount is not supported for flat price",
	models.WithWarningSeverity(),
	commonhttp.WithHTTPStatusCodeAttribute(http.StatusBadRequest),
)

var ValidateRateCardsHaveCompatibleBillingCadence = models.ValidatorFunc[RateCardWithOverlay](func(r RateCardWithOverlay) error {
	if r.base == nil || r.overlay == nil {
		return nil
	}

	var errs []error

	rBillingCadence, vBillingCadence := r.base.GetBillingCadence(), r.overlay.GetBillingCadence()

	fieldSelector := models.NewFieldSelectorGroup(models.NewFieldSelector("ratecards").
		WithExpression(models.NewFieldAttrValue("key", r.base.Key())))

	if rBillingCadence != nil && vBillingCadence != nil && !rBillingCadence.Equal(vBillingCadence) {
		errs = append(errs, models.ErrorWithFieldPrefix(fieldSelector, ErrRateCardBillingCadenceMismatch))
	}

	return errors.Join(errs...)
})

var ValidateRateCardsHaveCompatibleDiscounts = models.ValidatorFunc[RateCardWithOverlay](func(r RateCardWithOverlay) error {
	if r.base == nil || r.overlay == nil {
		return nil
	}

	var errs []error

	rMeta, vMeta := r.base.AsMeta(), r.overlay.AsMeta()

	if rMeta.Discounts.Percentage != nil && vMeta.Discounts.Percentage != nil {
		fieldSelector := models.NewFieldSelectorGroup(models.NewFieldSelector("discounts"))

		errs = append(errs, models.ErrorWithFieldPrefix(fieldSelector, ErrRateCardPercentageDiscountNotAllowed))
	}

	err := errors.Join(errs...)
	if err != nil {
		fieldSelector := models.NewFieldSelectorGroup(
			models.NewFieldSelector("ratecards").
				WithExpression(models.NewFieldAttrValue("key", r.base.Key())),
		)

		return models.ErrorWithFieldPrefix(fieldSelector, err)
	}

	return nil
})

var ValidateRateCardsHaveCompatibleEntitlementTemplate = models.ValidatorFunc[RateCardWithOverlay](func(r RateCardWithOverlay) error {
	if r.base == nil || r.overlay == nil {
		return nil
	}

	var errs []error

	rMeta, vMeta := r.base.AsMeta(), r.overlay.AsMeta()

	if rMeta.EntitlementTemplate != nil && vMeta.EntitlementTemplate != nil {
		if rMeta.EntitlementTemplate.Type() != vMeta.EntitlementTemplate.Type() {
			errs = append(errs, ErrRateCardEntitlementTemplateTypeMismatch)
		} else {
			switch rMeta.EntitlementTemplate.Type() {
			case entitlement.EntitlementTypeStatic:
				errs = append(errs, ErrRateCardStaticEntitlementTemplateNotAllowed)
			case entitlement.EntitlementTypeMetered:
				rMetered, err := rMeta.EntitlementTemplate.AsMetered()
				if err != nil {
					return err
				}

				vMetered, err := vMeta.EntitlementTemplate.AsMetered()
				if err != nil {
					return err
				}

				if !rMetered.UsagePeriod.Equal(&vMetered.UsagePeriod) {
					errs = append(errs, ErrRateCardMeteredEntitlementTemplateUsagePeriodMismatch)
				}
			case entitlement.EntitlementTypeBoolean:
			}
		}
	}

	err := errors.Join(errs...)
	if err != nil {
		fieldSelector := models.NewFieldSelectorGroup(
			models.NewFieldSelector("ratecards").
				WithExpression(models.NewFieldAttrValue("key", r.base.Key())),
			models.NewFieldSelector("entitlementTemplate"),
		)

		return models.ErrorWithFieldPrefix(fieldSelector, err)
	}

	return nil
})

var ValidateRateCardsHaveCompatibleFeatureID = models.ValidatorFunc[RateCardWithOverlay](func(r RateCardWithOverlay) error {
	if r.base == nil || r.overlay == nil {
		return nil
	}

	rMeta, vMeta := r.base.AsMeta(), r.overlay.AsMeta()

	fieldSelector := models.NewFieldSelectorGroup(models.NewFieldSelector("ratecards").
		WithExpression(models.NewFieldAttrValue("key", r.base.Key())))

	if rMeta.FeatureID != nil && vMeta.FeatureID != nil && *rMeta.FeatureID != *vMeta.FeatureID {
		return models.ErrorWithFieldPrefix(fieldSelector, ErrRateCardFeatureIDMismatch)
	}

	return nil
})

var ValidateRateCardsHaveCompatibleFeatureKey = models.ValidatorFunc[RateCardWithOverlay](func(r RateCardWithOverlay) error {
	if r.base == nil || r.overlay == nil {
		return nil
	}

	rMeta, vMeta := r.base.AsMeta(), r.overlay.AsMeta()

	fieldSelector := models.NewFieldSelectorGroup(models.NewFieldSelector("ratecards").
		WithExpression(models.NewFieldAttrValue("key", r.base.Key())))

	if rMeta.FeatureKey != nil && vMeta.FeatureKey != nil && *rMeta.FeatureKey != *vMeta.FeatureKey {
		return models.ErrorWithFieldPrefix(fieldSelector, ErrRateCardFeatureKeyMismatch)
	}

	return nil
})

var ValidateRateCardsHaveCompatiblePrice = models.ValidatorFunc[RateCardWithOverlay](func(r RateCardWithOverlay) error {
	if r.base == nil || r.overlay == nil {
		return nil
	}

	var errs []error

	rMeta, vMeta := r.base.AsMeta(), r.overlay.AsMeta()

	fieldSelector := models.NewFieldSelectorGroup(models.NewFieldSelector("ratecards").
		WithExpression(models.NewFieldAttrValue("key", r.base.Key())))

	if rMeta.Price != nil && vMeta.Price != nil {
		if rMeta.Price.Type() != vMeta.Price.Type() {
			errs = append(errs, models.ErrorWithFieldPrefix(fieldSelector, ErrRateCardPriceTypeMismatch))
		}

		switch rMeta.Price.Type() {
		case FlatPriceType:
			rFlat, _ := rMeta.Price.AsFlat()
			vFlat, _ := vMeta.Price.AsFlat()

			if rFlat.PaymentTerm != vFlat.PaymentTerm {
				errs = append(errs, models.ErrorWithFieldPrefix(fieldSelector, ErrRateCardPricePaymentTermMismatch))
			}
		default:
			errs = append(errs, models.ErrorWithFieldPrefix(fieldSelector, ErrRateCardOnlyFlatPriceAllowed))
		}
	}

	return errors.Join(errs...)
})

var ValidateRateCardsHaveCompatibleUnitConfig = models.ValidatorFunc[RateCardWithOverlay](func(r RateCardWithOverlay) error {
	if r.base == nil || r.overlay == nil {
		return nil
	}

	rMeta, vMeta := r.base.AsMeta(), r.overlay.AsMeta()

	if rMeta.UnitConfig != nil && vMeta.UnitConfig != nil && !rMeta.UnitConfig.Equal(vMeta.UnitConfig) {
		fieldSelector := models.NewFieldSelectorGroup(models.NewFieldSelector("ratecards").
			WithExpression(models.NewFieldAttrValue("key", r.base.Key())))

		return models.ErrorWithFieldPrefix(fieldSelector, ErrAddonRateCardUnitConfigMismatch)
	}

	return nil
})

var ValidateRateCardsShareSameKey = models.ValidatorFunc[RateCardWithOverlay](func(r RateCardWithOverlay) error {
	if r.base == nil || r.overlay == nil {
		return nil
	}

	fieldSelector := models.NewFieldSelectorGroup(models.NewFieldSelector("ratecards").
		WithExpression(models.NewFieldAttrValue("key", r.base.Key())))

	if r.base.Key() != r.overlay.Key() {
		return models.ErrorWithFieldPrefix(fieldSelector, ErrRateCardKeyMismatch)
	}

	return nil
})