subscription

type AllowedDuringApplyingPatchesError struct {
	Inner error
}

type AnyValuePatch interface {
	ValueAsAny() any
}

type Applies interface {
	ApplyTo(spec *SubscriptionSpec, actx ApplyContext) error
}

type ApplyContext struct {
	Operation   SpecOperation
	CurrentTime time.Time
}

type CancelledEvent viewEvent

type ChangeSubscriptionWorkflowInput struct {
	ActiveFrom time.Time
	models.AnnotatedModel
	Name        string
	Description *string
}

type ContinuedEvent viewEvent

type CreateSubscriptionCustomerInput struct {
	models.AnnotatedModel `json:",inline"`
	Name                  string         `json:"name"`
	Description           *string        `json:"description,omitempty"`
	CustomerId            string         `json:"customerId"`
	Currency              currencyx.Code `json:"currency"`
	ActiveFrom            time.Time      `json:"activeFrom,omitempty"`
	ActiveTo              *time.Time     `json:"activeTo,omitempty"`
}

type CreateSubscriptionEntityInput struct {
	models.CadencedModel
	models.NamespacedModel
	models.AnnotatedModel

	Plan        *PlanRef
	Name        string  `json:"name,omitempty"`
	Description *string `json:"description,omitempty"`

	CustomerId string `json:"customerId,omitempty"`
	Currency   currencyx.Code
}

type CreateSubscriptionItemCustomerInput struct {
	ActiveFromOverrideRelativeToPhaseStart *datex.Period `json:"activeFromOverrideRelativeToPhaseStart"`
	ActiveToOverrideRelativeToPhaseStart   *datex.Period `json:"activeToOverrideRelativeToPhaseStart,omitempty"`
}

type CreateSubscriptionItemEntityInput struct {
	models.NamespacedModel
	models.AnnotatedModel

	ActiveFromOverrideRelativeToPhaseStart *datex.Period
	ActiveToOverrideRelativeToPhaseStart   *datex.Period

	models.CadencedModel

	// PhaseID is the ID of the phase this item belongs to.
	PhaseID string

	// Key is the unique key of the item in the phase.
	Key string

	RateCard RateCard

	EntitlementID *string
	Name          string  `json:"name,omitempty"`
	Description   *string `json:"description,omitempty"`
}

type CreateSubscriptionItemInput struct {
	CreateSubscriptionItemPlanInput     `json:",inline"`
	CreateSubscriptionItemCustomerInput `json:",inline"`
}

type CreateSubscriptionItemPlanInput struct {
	PhaseKey string   `json:"phaseKey"`
	ItemKey  string   `json:"itemKey"`
	RateCard RateCard `json:"rateCard"`
}

type CreateSubscriptionPhaseCustomerInput struct {
	models.AnnotatedModel `json:",inline"`
}

type CreateSubscriptionPhaseEntityInput struct {
	models.NamespacedModel
	models.AnnotatedModel

	// ActiveFrom is the time the phase becomes active.
	ActiveFrom time.Time

	// SubscriptionID is the ID of the subscription this phase belongs to.
	SubscriptionID string `json:"subscriptionId"`

	// Key is the unique key for Phase.
	Key string `json:"key"`

	// Name
	Name string `json:"name"`

	// Description
	Description *string `json:"description,omitempty"`

	// StartAfter
	StartAfter datex.Period `json:"interval"`
}

type CreateSubscriptionPhaseInput struct {
	// Duration is required exactly in cases where the phase wouldn't be the last phase.
	Duration *datex.Period `json:"duration"`
	CreateSubscriptionPhasePlanInput
	CreateSubscriptionPhaseCustomerInput
}

type CreateSubscriptionPhasePlanInput struct {
	PhaseKey    string       `json:"key"`
	StartAfter  datex.Period `json:"startAfter"`
	Name        string       `json:"name"`
	Description *string      `json:"description,omitempty"`
}

type CreateSubscriptionPlanInput struct {
	Plan *PlanRef `json:"plan"`
}

type CreateSubscriptionWorkflowInput struct {
	ChangeSubscriptionWorkflowInput
	Namespace  string
	CustomerID string
}

type CreatedEvent viewEvent

type EntitlementAdapter interface {
	ScheduleEntitlement(ctx context.Context, input ScheduleSubscriptionEntitlementInput) (*SubscriptionEntitlement, error)
	// At refers to a point in time for which we're querying the system state, meaning:
	// if t1 < t2 < t3, and some entitlement was deleted effective at t2, then
	// with at = t1 the entitlement will be returned, while with at = t3 it won't.
	GetForSubscriptionAt(ctx context.Context, subscriptionID models.NamespacedID, at time.Time) ([]SubscriptionEntitlement, error)

	DeleteByItemID(ctx context.Context, itemId models.NamespacedID) error
}

type ForbiddenError struct {
	Msg string
}

type ItemNotFoundError struct {
	ID string
}

type NotFoundError struct {
	ID         string
	CustomerID string
}

type Patch interface {
	json.Marshaler
	Applies
	Validate() error
	Op() PatchOperation
	Path() PatchPath
}

type PatchConflictError struct {
	Msg string
}

type PatchForbiddenError struct {
	Msg string
}

type PatchOperation string

type PatchPath string

type PatchPathType string

type PatchValidationError struct {
	Msg string
}

type PhaseNotFoundError struct {
	ID string
}

type Plan interface {
	ToCreateSubscriptionPlanInput() CreateSubscriptionPlanInput

	// Phases are expected to be returned in the order they activate.
	GetPhases() []PlanPhase

	// Will not make sense on the long term
	Currency() currencyx.Code
}

type PlanNotFoundError struct {
	Key     string
	Version int
}

type PlanPhase interface {
	ToCreateSubscriptionPhasePlanInput() CreateSubscriptionPhasePlanInput
	GetRateCards() []PlanRateCard
	GetKey() string
}

type PlanRateCard interface {
	ToCreateSubscriptionItemPlanInput() CreateSubscriptionItemPlanInput
	GetKey() string
}

type PlanRef struct {
	Id      string `json:"id"`
	Key     string `json:"key"`
	Version int    `json:"version"`
}

type RateCard struct {
	// Name of the RateCard
	Name string `json:"name"`

	// Description for the RateCard
	Description *string `json:"description,omitempty"`

	// Feature defines optional Feature assigned to RateCard
	FeatureKey *string `json:"featureKey,omitempty"`

	// EntitlementTemplate defines the template used for instantiating entitlement.Entitlement.
	// If Feature is set then template must be provided as well.
	EntitlementTemplate *productcatalog.EntitlementTemplate `json:"entitlementTemplate,omitempty"`

	// TaxConfig defines provider specific tax information.
	TaxConfig *productcatalog.TaxConfig `json:"taxConfig,omitempty"`

	// Price defines the price for the RateCard
	Price *productcatalog.Price `json:"price,omitempty"`

	// BillingCadence defines the billing cadence of the RateCard in ISO8601 format.
	// Example: "P1D12H"
	BillingCadence *datex.Period `json:"billingCadence,omitempty"`
}

type RemoveSubscriptionPhaseInput struct {
	Shift RemoveSubscriptionPhaseShifting `json:"shift"`
}

type RemoveSubscriptionPhaseShifting int

type ScheduleSubscriptionEntitlementInput struct {
	entitlement.CreateEntitlementInputs
}

type Service interface {
	// Create a new subscription accotding to the given spec
	Create(ctx context.Context, namespace string, spec SubscriptionSpec) (Subscription, error)
	// Update the subscription with the given ID to the target spec
	Update(ctx context.Context, subscriptionID models.NamespacedID, target SubscriptionSpec) (Subscription, error)
	// Delete a scheduled subscription with the given ID
	Delete(ctx context.Context, subscriptionID models.NamespacedID) error
	// Cancel a running subscription at the provided time
	Cancel(ctx context.Context, subscriptionID models.NamespacedID, at time.Time) (Subscription, error)
	// Continue a canceled subscription (effectively undoing the cancellation)
	Continue(ctx context.Context, subscriptionID models.NamespacedID) (Subscription, error)
	// Get the subscription with the given ID
	Get(ctx context.Context, subscriptionID models.NamespacedID) (Subscription, error)
	// GetView returns a full view of the subscription with the given ID
	GetView(ctx context.Context, subscriptionID models.NamespacedID) (SubscriptionView, error)
}

type SpecOperation int

type SpecValidationError struct {
	// TODO: This spec is broken and painful, lets improve it
	AffectedKeys [][]string
	Msg          string
}

type Subscription struct {
	models.NamespacedID
	models.ManagedModel
	models.CadencedModel
	models.AnnotatedModel

	Name        string  `json:"name,omitempty"`
	Description *string `json:"description,omitempty"`

	// References the plan (if the Subscription was created form one)
	PlanRef *PlanRef `json:"planRef"`

	CustomerId string         `json:"customerId,omitempty"`
	Currency   currencyx.Code `json:"currency,omitempty"`
}

type SubscriptionAction string

type SubscriptionEntitlement struct {
	Entitlement entitlement.Entitlement
	Cadence     models.CadencedModel
}

type SubscriptionItem struct {
	models.NamespacedID   `json:",inline"`
	models.ManagedModel   `json:",inline"`
	models.AnnotatedModel `json:",inline"`

	// SubscriptionItem doesn't have a separate Cadence, only one relative to the phase, denoting if it's intentionally different from the phase's cadence.
	// The durations are relative to phase start.
	ActiveFromOverrideRelativeToPhaseStart *datex.Period `json:"activeFromOverrideRelativeToPhaseStart,omitempty"`
	ActiveToOverrideRelativeToPhaseStart   *datex.Period `json:"activeToOverrideRelativeToPhaseStart,omitempty"`

	// The defacto cadence of the item is calculated and persisted after each change.
	models.CadencedModel `json:",inline"`

	// SubscriptionID is the ID of the subscription this item belongs to.
	SubscriptionId string `json:"subscriptionId"`
	// PhaseID is the ID of the phase this item belongs to.
	PhaseId string `json:"phaseId"`
	// Key is the unique key of the item in the phase.
	Key string `json:"itemKey"`

	RateCard RateCard `json:"rateCard"`

	EntitlementID *string `json:"entitlementId,omitempty"`
	// Name
	Name string `json:"name"`

	// Description
	Description *string `json:"description,omitempty"`
}

type SubscriptionItemRef struct {
	SubscriptionId string `json:"subscriptionId"`
	PhaseKey       string `json:"phaseKey"`
	ItemKey        string `json:"itemKey"`
}

type SubscriptionItemRepository interface {
	entutils.TxCreator

	GetForSubscriptionAt(ctx context.Context, subscriptionID models.NamespacedID, at time.Time) ([]SubscriptionItem, error)

	Create(ctx context.Context, input CreateSubscriptionItemEntityInput) (SubscriptionItem, error)
	Delete(ctx context.Context, id models.NamespacedID) error
	GetByID(ctx context.Context, id models.NamespacedID) (SubscriptionItem, error)
}

type SubscriptionItemSpec struct {
	CreateSubscriptionItemInput `json:",inline"`
}

type SubscriptionItemView struct {
	SubscriptionItem SubscriptionItem     `json:"subscriptionItem"`
	Spec             SubscriptionItemSpec `json:"spec"`

	Entitlement *SubscriptionEntitlement `json:"entitlement,omitempty"`
}

type SubscriptionPhase struct {
	models.NamespacedID   `json:",inline"`
	models.ManagedModel   `json:",inline"`
	models.AnnotatedModel `json:",inline"`

	ActiveFrom time.Time `json:"activeFrom"`

	// SubscriptionID is the ID of the subscription this phase belongs to.
	SubscriptionID string `json:"subscriptionId"`

	// Key is the unique key for Phase.
	Key string `json:"key"`

	// Name
	Name string `json:"name"`

	// Description
	Description *string `json:"description,omitempty"`
}

type SubscriptionPhaseRepository interface {
	entutils.TxCreator

	// Returns the phases for a subscription
	GetForSubscriptionAt(ctx context.Context, subscriptionID models.NamespacedID, at time.Time) ([]SubscriptionPhase, error)

	// Create a new subscription phase
	Create(ctx context.Context, input CreateSubscriptionPhaseEntityInput) (SubscriptionPhase, error)
	Delete(ctx context.Context, id models.NamespacedID) error
}

type SubscriptionPhaseSpec struct {
	// Duration is not part of the Spec by design
	CreateSubscriptionPhasePlanInput     `json:",inline"`
	CreateSubscriptionPhaseCustomerInput `json:",inline"`

	// In each key, for each phase, we have a list of item specs to account for mid-phase changes
	ItemsByKey map[string][]SubscriptionItemSpec `json:"itemsByKey"`
}

type SubscriptionPhaseView struct {
	SubscriptionPhase SubscriptionPhase                 `json:"subscriptionPhase"`
	Spec              SubscriptionPhaseSpec             `json:"spec"`
	ItemsByKey        map[string][]SubscriptionItemView `json:"itemsByKey"`
}

type SubscriptionRepository interface {
	entutils.TxCreator

	models.CadencedResourceRepo[Subscription]

	// Returns all subscriptions active or scheduled after the given timestamp
	GetAllForCustomerSince(ctx context.Context, customerID models.NamespacedID, at time.Time) ([]Subscription, error)

	// Returns the subscription by ID
	GetByID(ctx context.Context, subscriptionID models.NamespacedID) (Subscription, error)

	// Create a new subscription
	Create(ctx context.Context, input CreateSubscriptionEntityInput) (Subscription, error)

	// Delete a subscription
	Delete(ctx context.Context, id models.NamespacedID) error
}

type SubscriptionSpec struct {
	CreateSubscriptionPlanInput     `json:",inline"`
	CreateSubscriptionCustomerInput `json:",inline"`

	// We use pointers so Patches can manipulate the spec
	Phases map[string]*SubscriptionPhaseSpec `json:"phases"`
}

type SubscriptionStateMachine struct {
	// contains filtered or unexported fields
}

type SubscriptionStatus string

type SubscriptionView struct {
	Subscription Subscription            `json:"subscription"`
	Customer     customerentity.Customer `json:"customer"`
	Spec         SubscriptionSpec        `json:"spec"`
	Phases       []SubscriptionPhaseView `json:"phases"`
}

type UpdatedEvent struct {
	// We can consider adding the old version or diff here if needed
	UpdatedView SubscriptionView `json:"updatedView"`
}

type ValuePatch[T any] interface {
	Patch
	Value() T
	AnyValuePatch
}

type WorkflowService interface {
	CreateFromPlan(ctx context.Context, inp CreateSubscriptionWorkflowInput, plan Plan) (SubscriptionView, error)
	EditRunning(ctx context.Context, subscriptionID models.NamespacedID, customizations []Patch) (SubscriptionView, error)
	ChangeToPlan(ctx context.Context, subscriptionID models.NamespacedID, inp ChangeSubscriptionWorkflowInput, plan Plan) (current Subscription, new SubscriptionView, err error)
}