licensing

type Config struct {
	// License key (JWT token)
	LicenseKey string
	// LicenseSource, when set, supplies the licence instead of LicenseKey,
	// and is read at start and at every validity check: a host embedding
	// Studio keeps the licence in its own settings, and a renewed licence
	// takes effect without a restart. It is the same AI Studio Enterprise
	// licence, validated the same way.
	LicenseSource func() string

	// Telemetry configuration
	TelemetryURL         string
	TelemetryPeriod      time.Duration
	TelemetryDisabled    bool
	ValidityCheckPeriod  time.Duration
	TelemetryConcurrency int

	// OnInvalid is called when a periodic re-check finds the licence no
	// longer valid. Nil exits the process, which is what the standalone
	// binaries rely on; an embedding host supplies its own handling.
	OnInvalid func(error)
}

type FactoryFunc func(config Config, db *gorm.DB) Service

type Feature struct {
	Name  string
	Value interface{}
}

type LicenseInfo struct {
	// JWT claims
	ExpiresAt time.Time
	IssuedAt  time.Time
	NotBefore time.Time
	Version   string

	// Feature entitlements from scope claim
	Features map[string]Feature

	// Raw token
	Token string
}

type Revalidator interface {
	Revalidate() error
}

type Service interface {
	// Start initializes and starts the licensing service
	// - Validates license at boot (ENT: returns an error if invalid)
	// - Starts periodic validation checks (ENT: every 24h)
	// - Starts telemetry collection (ENT: every 1h)
	Start() error

	// Stop gracefully stops all background processes
	Stop()

	// IsValid returns whether the license is currently valid
	// CE: Always returns true
	// ENT: Returns true if JWT is valid and not expired
	IsValid() bool

	// Entitlement checks if a specific feature is available
	// Returns the feature value and whether it exists
	// CE: All features return true
	// ENT: Checks JWT scope claim
	Entitlement(name string) (Feature, bool)

	// DaysLeft returns the number of days until license expiry
	// CE: Returns -1 (never expires)
	// ENT: Returns days until JWT exp claim
	DaysLeft() int

	// TelemetryMiddleware returns a Gin middleware for tracking HTTP requests
	// CE: No-op middleware
	// ENT: Tracks actions, status codes, access types
	TelemetryMiddleware() gin.HandlerFunc

	// SendTelemetry manually triggers a telemetry collection and send
	// CE: No-op
	// ENT: Collects stats and sends to telemetry endpoint
	SendTelemetry() error

	// GetLicenseInfo returns the current license information
	// CE: Returns nil
	// ENT: Returns parsed JWT claims and features
	GetLicenseInfo() *LicenseInfo
}

type TelemetryCollector interface {
	// CollectLLMStats collects LLM usage statistics
	CollectLLMStats(db *gorm.DB) (map[string]interface{}, error)

	// CollectAppStats collects application statistics
	CollectAppStats(db *gorm.DB) (map[string]interface{}, error)

	// CollectUserStats collects user statistics
	CollectUserStats(db *gorm.DB) (map[string]interface{}, error)

	// CollectChatStats collects chat statistics
	CollectChatStats(db *gorm.DB) (map[string]interface{}, error)
}

type TelemetryEvent struct {
	Identity   string                 `json:"identity"`   // Hashed license key
	Event      string                 `json:"event"`      // Event type
	Timestamp  int64                  `json:"timestamp"`  // Unix timestamp
	Properties map[string]interface{} `json:"properties"` // Event data
}