usecases

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

type ActivateSubscriptionCommand struct {
	SubscriptionID uint
}

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

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

type CancelSubscriptionCommand struct {
	SubscriptionID uint
	Reason         string
	Immediate      bool
}

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

type ChangePlanCommand struct {
	SubscriptionID uint
	NewPlanID      uint   // Internal plan ID (used if NewPlanSID is empty)
	NewPlanSID     string // Stripe-style plan SID (takes precedence over NewPlanID)
	ChangeType     ChangeType
	EffectiveDate  EffectiveDate
}

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

type ChangeType string

type CreatePlanCommand struct {
	Name        string
	Slug        string
	Description string
	PlanType    string // Required: "node" or "forward"
	Limits      map[string]interface{}
	NodeLimit   *int // Maximum number of user nodes (nil or 0 = unlimited)
	IsPublic    bool
	SortOrder   int
	Pricings    []dto.PricingOptionInput // Required: multiple pricing options
}

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

type CreateSubscriptionCommand struct {
	UserID              uint   // Internal user ID (used if UserSID is empty)
	UserSID             string // Stripe-style user SID (takes precedence over UserID)
	PlanID              uint   // Internal plan ID (used if PlanSID is empty)
	PlanSID             string // Stripe-style plan SID (takes precedence over PlanID)
	StartDate           time.Time
	AutoRenew           bool
	PaymentInfo         map[string]interface{}
	BillingCycle        string // User selected billing cycle
	ActivateImmediately bool   // If true, activate subscription immediately (for admin use)
}

type CreateSubscriptionResult struct {
	Subscription *subscription.Subscription
	Plan         *subscription.Plan // Plan used for this subscription (for DTO device_limit)
	Token        *subscription.SubscriptionToken
	PlainToken   string // Plain token value, only available at creation time
}

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

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

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

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

type EffectiveDate string

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

type GenerateSubscriptionTokenCommand struct {
	SubscriptionID uint
	Name           string
	Scope          string
	ExpiresAt      *time.Time
}

type GenerateSubscriptionTokenResult struct {
	Token     string     `json:"token"`
	TokenID   uint       `json:"token_id"`
	Prefix    string     `json:"prefix"`
	ExpiresAt *time.Time `json:"expires_at,omitempty"`
	CreatedAt time.Time  `json:"created_at"`
}

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

type GetPlanPricingsQuery struct {
	PlanSID string
}

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

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

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

type GetSubscriptionQuery struct {
	SubscriptionID uint
}

type GetSubscriptionUsageStatsQuery struct {
	SubscriptionID uint
	From           time.Time
	To             time.Time
	Granularity    string // hour, day, month
	Page           int
	PageSize       int
}

type GetSubscriptionUsageStatsResponse struct {
	Records  []*SubscriptionUsageStatsRecord `json:"records"`
	Summary  *SubscriptionUsageSummary       `json:"summary"`
	Total    int                             `json:"total"`
	Page     int                             `json:"page"`
	PageSize int                             `json:"page_size"`
}

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

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

type ListPlansQuery struct {
	Status   *string
	IsPublic *bool
	PlanType *string // Optional: filter by plan type ("node" or "forward")
	Page     int
	PageSize int
}

type ListPlansResult struct {
	Plans []*dto.PlanDTO `json:"plans"`
	Total int64          `json:"total"`
}

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

type ListSubscriptionTokensQuery struct {
	SubscriptionID uint
	ActiveOnly     bool
}

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

type ListUserSubscriptionsQuery struct {
	UserID        *uint // nil means all users (admin only)
	PlanID        *uint
	Status        *string
	BillingCycle  *string
	CreatedFrom   *time.Time
	CreatedTo     *time.Time
	ExpiresBefore *time.Time
	Page          int
	PageSize      int
	SortBy        string
	SortDesc      *bool // nil means default (true = DESC)
}

type ListUserSubscriptionsResult struct {
	Subscriptions []*dto.SubscriptionDTO `json:"subscriptions"`
	Total         int64                  `json:"total"`
	Page          int                    `json:"page"`
	PageSize      int                    `json:"page_size"`
}

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

type OnlineDeviceCounter interface {
	GetOnlineDeviceCount(ctx context.Context, subscriptionID uint) (int, error)
	GetOnlineDeviceCounts(ctx context.Context, subscriptionIDs []uint) (map[uint]int, error)
}

type PlanChangeNotifier interface {
	NotifyPlanFeaturesChanged(ctx context.Context, planID uint) error
}

type QuotaCacheManager interface {
	// InvalidateQuota removes quota cache for a subscription, forcing reload on next access.
	InvalidateQuota(ctx context.Context, subscriptionID uint) error
	// SyncQuotaFromSubscription syncs quota from subscription to cache.
	SyncQuotaFromSubscription(ctx context.Context, sub *subscription.Subscription) error
	// SetSuspended updates only the suspended status in cache.
	SetSuspended(ctx context.Context, subscriptionID uint, suspended bool) error
}

type QuotaCheckResult struct {
	SubscriptionID  uint      // Internal subscription ID
	SubscriptionSID string    // Stripe-style subscription ID
	PlanType        string    // Plan type (node, forward, hybrid)
	UsedBytes       uint64    // Total traffic used in current period
	LimitBytes      uint64    // Traffic limit (0 = unlimited)
	PeriodStart     time.Time // Current billing period start
	PeriodEnd       time.Time // Current billing period end
	IsExceeded      bool      // Whether quota is exceeded
	RemainingBytes  uint64    // Remaining traffic (0 if exceeded or unlimited)
}

type QuotaService interface {
	// GetSubscriptionQuota returns the quota usage for a single subscription.
	GetSubscriptionQuota(ctx context.Context, subscriptionID uint) (*QuotaCheckResult, error)

	// GetUserForwardQuota returns quota usage for all Forward-type subscriptions of a user.
	GetUserForwardQuota(ctx context.Context, userID uint) ([]*QuotaCheckResult, error)

	// GetUserNodeQuota returns quota usage for all Node-type subscriptions of a user.
	GetUserNodeQuota(ctx context.Context, userID uint) ([]*QuotaCheckResult, error)

	// CheckUserForwardQuotaExceeded checks if user's Forward quota is exceeded.
	// Returns true if all Forward subscriptions have exceeded their quota.
	CheckUserForwardQuotaExceeded(ctx context.Context, userID uint) (bool, error)

	// GetCurrentPeriodUsage returns the total usage for the current billing period.
	// This method is used for real-time traffic limit checking.
	GetCurrentPeriodUsage(ctx context.Context, subscriptionID uint, periodStart, periodEnd time.Time) (int64, error)
}

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

type RefreshSubscriptionTokenCommand struct {
	OldTokenID uint
}

type RefreshSubscriptionTokenResult struct {
	NewToken  string     `json:"new_token"`
	TokenID   uint       `json:"token_id"`
	ExpiresAt *time.Time `json:"expires_at,omitempty"`
}

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

type RenewSubscriptionCommand struct {
	SubscriptionID uint
	BillingCycle   string // Optional: billing cycle for renewal period. If empty, uses current subscription's billing cycle.
	IsAutoRenew    bool
}

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

type ResetSubscriptionLinkCommand struct {
	SubscriptionID uint
}

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

type ResetSubscriptionUsageCommand struct {
	SubscriptionID uint
}

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

type RevokeSubscriptionTokenCommand struct {
	TokenID uint
}

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

type SubscriptionChangeNotifier interface {
	// NotifySubscriptionActivation notifies nodes when a subscription becomes active.
	NotifySubscriptionActivation(ctx context.Context, sub *subscription.Subscription) error
	// NotifySubscriptionDeactivation notifies nodes when a subscription is deactivated/expired/cancelled.
	NotifySubscriptionDeactivation(ctx context.Context, sub *subscription.Subscription) error
	// NotifySubscriptionUpdate notifies nodes when a subscription is updated.
	NotifySubscriptionUpdate(ctx context.Context, sub *subscription.Subscription) error
}

type SubscriptionUsageStatsRecord struct {
	ResourceType string    `json:"resource_type"`
	ResourceSID  string    `json:"resource_id"` // Stripe-style SID (node_xxx or fwd_xxx)
	Upload       uint64    `json:"upload"`
	Download     uint64    `json:"download"`
	Total        uint64    `json:"total"`
	Period       time.Time `json:"period"`
}

type SubscriptionUsageSummary struct {
	TotalUpload   uint64 `json:"total_upload"`
	TotalDownload uint64 `json:"total_download"`
	Total         uint64 `json:"total"`
}

type SuspendSubscriptionCommand struct {
	SubscriptionID uint
	Reason         string
}

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

type TokenGenerator interface {
	Generate(prefix string) (plainToken string, hash string, err error)
	Hash(plainToken string) string
}

type UnsuspendSubscriptionCommand struct {
	SubscriptionID uint
}

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

type UpdatePlanCommand struct {
	PlanSID     string
	Description *string
	Limits      *map[string]interface{}
	NodeLimit   *int // Maximum number of user nodes (nil or 0 = unlimited)
	SortOrder   *int
	IsPublic    *bool
	Pricings    *[]dto.PricingOptionInput // Optional: update pricing options
}

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

type ValidateSubscriptionTokenCommand struct {
	PlainToken    string
	RequiredScope string
	IPAddress     string
}

type ValidateSubscriptionTokenResult struct {
	Token        *subscription.SubscriptionToken
	Subscription *subscription.Subscription
	Plan         *subscription.Plan
}

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