trustedai

type APIToken struct {
	ID          string     `json:"id"`
	UserID      string     `json:"userId"`
	Description string     `json:"description"`
	PrefixHash  string     `json:"-"` // SHA256 of token prefix for lookups
	TokenHash   string     `json:"-"` // Argon2id hash of full token
	CreatedAt   time.Time  `json:"createdAt"`
	ExpiresAt   time.Time  `json:"expiresAt"`
	LastUsedAt  *time.Time `json:"lastUsedAt,omitempty"`
}

type BillingRepository interface {
	// CreateBillingSummary stores a new billing summary
	CreateBillingSummary(ctx context.Context, summary *BillingSummary) error

	// GetBillingSummary retrieves a billing summary by ID
	GetBillingSummary(ctx context.Context, id string) (*BillingSummary, error)

	// ListBillingSummariesByUser retrieves billing summaries for a specific user
	ListBillingSummariesByUser(ctx context.Context, userID string, limit, offset int) ([]*BillingSummary, error)

	// ListBillingSummariesByPeriod retrieves billing summaries for a specific period
	ListBillingSummariesByPeriod(ctx context.Context, start, end time.Time) ([]*BillingSummary, error)

	// GetBillingSummaryForUserPeriod retrieves existing billing summary for a user and period
	GetBillingSummaryForUserPeriod(ctx context.Context, userID string, start, end time.Time) (*BillingSummary, error)

	// UpdateBillingSummary updates an existing billing summary
	UpdateBillingSummary(ctx context.Context, summary *BillingSummary) error
}

type BillingSummary struct {
	ID                string    `json:"id"`
	UserID            string    `json:"userId"`
	PeriodStart       time.Time `json:"periodStart"`
	PeriodEnd         time.Time `json:"periodEnd"`
	TotalRequests     int       `json:"totalRequests"`
	TotalInputTokens  int64     `json:"totalInputTokens"`
	TotalOutputTokens int64     `json:"totalOutputTokens"`
	TotalCostCents    float64   `json:"totalCostCents"`
	CreatedAt         time.Time `json:"createdAt"`
}

type ContextKey struct{}

type CostResult struct {
	InputCostCents  float64 `json:"inputCostCents"`
	OutputCostCents float64 `json:"outputCostCents"`
	TotalCostCents  float64 `json:"totalCostCents"`
}

type CredentialRepository interface {
	GetOpenRouterCredential(ctx context.Context, credentialID uuid.UUID) (*OpenRouterCredential, error)
	ListOpenRouterCredentials(ctx context.Context) ([]OpenRouterCredential, error)
	CreateOpenRouterCredential(ctx context.Context, cred *OpenRouterCredential) error
	UpdateOpenRouterCredential(ctx context.Context, cred *OpenRouterCredential) error
	DeleteOpenRouterCredential(ctx context.Context, credentialID uuid.UUID) error
}

type DeviceAuthResponse struct {
	DeviceCode      string
	UserCode        string
	VerificationURI string
	ExpiresIn       time.Duration
	Interval        time.Duration
}

type ModelRepository interface {
	GetAllModels(ctx context.Context) ([]ModelWithCredentials, error)
	GetModelByID(ctx context.Context, modelID string) (*ModelWithCredentials, error)
	CreateModel(ctx context.Context, model *gai.Model, credentialID uuid.UUID, credentialType trustedaiv1.CredentialType) error
	UpdateModel(ctx context.Context, model *gai.Model, credentialID uuid.UUID, credentialType trustedaiv1.CredentialType) error
	DeleteModel(ctx context.Context, modelID string) error
}

type ModelWithCredentials struct {
	Model          gai.Model
	CredentialID   uuid.UUID
	CredentialType trustedaiv1.CredentialType
}

type OpenRouterCredential struct {
	ID          uuid.UUID `json:"id"`
	Name        string    `json:"name"`
	Description string    `json:"description"`
	APIKey      string    `json:"api_key"`
	SiteName    string    `json:"site_name"`
	HTTPReferer string    `json:"http_referer"`
	Enabled     bool      `json:"enabled"`
}

type Organization struct {
	ID          string    `json:"id"`
	Name        string    `json:"name"`
	DisplayName string    `json:"displayName"`
	IsSystem    bool      `json:"isSystem"` // Marks the platform's own organization
	CreatedAt   time.Time `json:"createdAt"`
	SSOType     string    `json:"ssoType"`   // "oidc", "saml", "github", etc
	SSOConfig   SSOConfig `json:"ssoConfig"` // Flexible provider configuration with redaction
}

type OrganizationRepository interface {
	Create(ctx context.Context, org *Organization) error
	Get(ctx context.Context, id string) (*Organization, error)
	GetByName(ctx context.Context, name string) (*Organization, error)
	List(ctx context.Context) ([]*Organization, error)
	ListForUser(ctx context.Context, user *User) ([]*Organization, error)
	Update(ctx context.Context, org *Organization) error
	Delete(ctx context.Context, id string) error
}

type ProviderConfig struct {
	ID           string `json:"id"`
	Name         string `json:"name"`
	ProviderType string `json:"provider_type"`
	Enabled      bool   `json:"enabled"`
}

type ProviderRepository interface {
	GetAllProviders(ctx context.Context) ([]ProviderConfig, error)
	GetProviderByID(ctx context.Context, providerID string) (*ProviderConfig, error)
	CreateProvider(ctx context.Context, provider *ProviderConfig) error
	UpdateProvider(ctx context.Context, provider *ProviderConfig) error
	DeleteProvider(ctx context.Context, providerID string) error
}

type SSOConfig map[string]any

type SsoProvider interface {
	GetAuthURL(ctx context.Context, state string) (string, error)
	HandleCallback(ctx context.Context, code string) (*User, error)
	ValidateToken(ctx context.Context, token string) (bool, map[string]any, error)

	// Device Flow additions
	StartDeviceAuth(ctx context.Context) (*DeviceAuthResponse, error)
	CheckDeviceAuth(ctx context.Context, deviceCode string) (*User, error)
}

type TokenRepository interface {
	// CreateToken generates and stores a new API token
	CreateToken(
		ctx context.Context,
		userID string,
		description string,
		expiresAt time.Time,
	) (*APIToken, string, error) // Returns token record and raw token

	// GetTokenByPrefixHash retrieves token by hashed prefix
	GetTokenByPrefixHash(ctx context.Context, prefixHash string) (*APIToken, error)

	// RevokeToken permanently invalidates a token
	RevokeToken(ctx context.Context, tokenID string) error

	// ListUserTokens returns all active tokens for a user
	ListUserTokens(ctx context.Context, userID string) ([]*APIToken, error)

	// ListUserTokensForUser returns tokens visible to the requesting user
	ListUserTokensForUser(ctx context.Context, requestingUser *User, targetUserID string) ([]*APIToken, error)

	// ListAllTokensForUser returns all tokens visible to the requesting user
	ListAllTokensForUser(ctx context.Context, requestingUser *User) ([]*APIToken, error)

	// RevokeTokenForUser revokes a token if the requesting user has permission
	RevokeTokenForUser(ctx context.Context, requestingUser *User, tokenID string) error

	// UpdateTokenUsage records when a token was last used
	UpdateTokenUsage(ctx context.Context, tokenID string) error
}

type UsageEvent struct {
	ID              string    `json:"id"`
	RequestID       string    `json:"requestId"`
	UserID          string    `json:"userId"`
	ModelID         string    `json:"modelId"`
	InputTokens     *int      `json:"inputTokens,omitempty"`
	OutputTokens    *int      `json:"outputTokens,omitempty"`
	CachedTokens    *int      `json:"cachedTokens,omitempty"`
	ReasoningTokens *int      `json:"reasoningTokens,omitempty"`
	Status          string    `json:"status"`
	FailureStage    *string   `json:"failureStage,omitempty"`
	ErrorType       *string   `json:"errorType,omitempty"`
	ErrorMessage    *string   `json:"errorMessage,omitempty"`
	UsageDataSource string    `json:"usageDataSource"`
	DataComplete    bool      `json:"dataComplete"`
	Timestamp       time.Time `json:"timestamp"`
	DurationMs      *int      `json:"durationMs,omitempty"`
	InputCostCents  *float64  `json:"inputCostCents,omitempty"`
	OutputCostCents *float64  `json:"outputCostCents,omitempty"`
	TotalCostCents  *float64  `json:"totalCostCents,omitempty"`
}

type UsageRepository interface {
	// CreateUsageEvent stores a new usage event
	CreateUsageEvent(ctx context.Context, event *UsageEvent) error

	// GetUsageEvent retrieves a usage event by ID
	GetUsageEvent(ctx context.Context, id string) (*UsageEvent, error)

	// ListUsageEventsByUser retrieves usage events for a specific user with pagination
	ListUsageEventsByUser(ctx context.Context, userID string, limit, offset int) ([]*UsageEvent, error)

	// ListUsageEventsForCostCalculation retrieves uncalculated usage events that are ready for cost calculation
	ListUsageEventsForCostCalculation(ctx context.Context, limit int) ([]*UsageEvent, error)

	// UpdateUsageEventCost updates the cost fields for a usage event
	UpdateUsageEventCost(ctx context.Context, eventID string, cost CostResult) error

	// ListUsageEventsByPeriod retrieves usage events for a specific period
	ListUsageEventsByPeriod(ctx context.Context, userID string, start, end time.Time) ([]*UsageEvent, error)
}

type User struct {
	ID             string    `json:"id"`
	Email          string    `json:"email"`
	Name           string    `json:"name"`
	OrganizationID string    `json:"organizationId"`
	ExternalID     string    `json:"externalId"` // ID from identity provider
	Provider       string    `json:"provider"`   // "github", "okta", etc
	SystemAdmin    bool      `json:"systemAdmin"`
	CreatedAt      time.Time `json:"createdAt"`
	LastLogin      time.Time `json:"lastLogin"`
}

type UserRepository interface {
	Create(ctx context.Context, user *User) error
	Get(ctx context.Context, id string) (*User, error)
	GetByEmail(ctx context.Context, email string) (*User, error)
	GetByExternalID(ctx context.Context, provider, externalID string) (*User, error)
	ListByOrganization(ctx context.Context, orgID string) ([]*User, error)
	ListByOrganizationForUser(ctx context.Context, requestingUser *User, orgID string) ([]*User, error)
	ListAllForUser(ctx context.Context, requestingUser *User) ([]*User, error)
	Update(ctx context.Context, user *User) error
	Delete(ctx context.Context, id string) error
}