ddm

type AssignmentStore interface {
	AssignSet(ctx context.Context, id mdm.EnrollmentID, set string, at time.Time) (changed bool, err error)
	UnassignSet(ctx context.Context, id mdm.EnrollmentID, set string) (changed bool, err error)
	EnrollmentSets(ctx context.Context, id mdm.EnrollmentID) ([]string, error)
	SetEnrollments(ctx context.Context, set string, p storage.Page) (storage.Result[mdm.EnrollmentID], error)
	AssignDeclaration(ctx context.Context, id mdm.EnrollmentID, identifier string, at time.Time) (changed bool, err error)
	UnassignDeclaration(ctx context.Context, id mdm.EnrollmentID, identifier string) (changed bool, err error)
	// EnrollmentDeclarations lists direct assignments only, sorted.
	EnrollmentDeclarations(ctx context.Context, id mdm.EnrollmentID) ([]string, error)
	// StaticDeclarations is the union of direct assignments and set members,
	// deduplicated and sorted by identifier. Empty for an unknown id.
	StaticDeclarations(ctx context.Context, id mdm.EnrollmentID) ([]Declaration, error)
	// AffectedEnrollments lists every enrollment whose static membership
	// includes any of the identifiers or sets, deduplicated and sorted.
	AffectedEnrollments(ctx context.Context, identifiers, sets []string) ([]mdm.EnrollmentID, error)
}

type Change struct {
	Seq           int64
	ID            mdm.EnrollmentID
	Reason        string
	CreatedAt     time.Time
	Attempts      int
	LastError     string
	NextAttemptAt time.Time
}

type ChangeStore interface {
	// RecordChanges appends one row per id.
	RecordChanges(ctx context.Context, ids []mdm.EnrollmentID, reason string, at time.Time) error
	// PendingChanges returns rows due at or before now, oldest first.
	PendingChanges(ctx context.Context, now time.Time, limit int) ([]Change, error)
	CompleteChanges(ctx context.Context, seqs []int64) error
	// FailChanges records the error and the next attempt time; rows are
	// never deleted by a failure.
	FailChanges(ctx context.Context, seqs []int64, msg string, nextAttempt time.Time) error
	// ChangeStats counts rows due now and rows that have failed at least
	// once.
	ChangeStats(ctx context.Context, now time.Time) (pending, failed int64, err error)
}

type Config struct {
	Store     Store
	Resolvers []Resolver
	Expander  Expander
	Bus       *event.Bus
	Clock     clock.Clock
	Logger    *slog.Logger
	// Target supplies the validation target for uploads; nil validates for
	// any OS.
	Target func(ctx context.Context) support.Target
	// MaxStatusBytes bounds a status report; default 1 MiB.
	MaxStatusBytes int
	// KeepReports bounds raw status reports kept per enrollment; default 10.
	KeepReports   int
	Subscriptions Subscriptions
}

type Declaration struct {
	Identifier  string
	Type        string
	Kind        schemaddm.Kind
	ServerToken string
	Canonical   []byte
	CreatedAt   time.Time
	// UpdatedAt is the last time ServerToken changed.
	UpdatedAt time.Time
}

type DeclarationQuery struct {
	Kind  schemaddm.Kind
	Type  string
	InSet string
}

type DeclarationRef struct {
	Kind        schemaddm.Kind
	Identifier  string
	ServerToken string
}

type DeclarationStatus struct {
	Kind        schemaddm.Kind
	Identifier  string
	ServerToken string
	Active      bool
	// Valid is unknown, invalid, or valid as the device reported it.
	Valid string
	// Reasons is the raw JSON array of reasons, nil when none.
	Reasons   []byte
	FirstSeen time.Time
	LastSeen  time.Time
}

type DeclarationStore interface {
	// PutDeclaration upserts by Identifier. changed is false when the stored
	// ServerToken already equals d.ServerToken; nothing is written then.
	// ErrConflict when the identifier exists with a different Kind. Every
	// accepted change also records a DeclarationVersion.
	PutDeclaration(ctx context.Context, d *Declaration) (changed bool, err error)
	// GetDeclaration returns the current revision or ErrNotFound.
	GetDeclaration(ctx context.Context, identifier string) (*Declaration, error)
	// GetDeclarationVersion returns one revision or ErrNotFound.
	GetDeclarationVersion(ctx context.Context, identifier, serverToken string) (*DeclarationVersion, error)
	// DeleteDeclaration removes the declaration, its versions, set
	// memberships, and direct assignments. ErrNotFound when absent.
	DeleteDeclaration(ctx context.Context, identifier string) error
	// ListDeclarations pages by identifier.
	ListDeclarations(ctx context.Context, q DeclarationQuery, p storage.Page) (storage.Result[Declaration], error)
	// PruneVersions deletes revisions that are neither current nor named by
	// a snapshot item and returns how many.
	PruneVersions(ctx context.Context) (int64, error)
}

type DeclarationVersion struct {
	Identifier  string
	Type        string
	ServerToken string
	Canonical   []byte
	CreatedAt   time.Time
}

type DrainResult struct {
	// Deferred enrollments were left for a later drain because a change
	// arrived within Window.
	Deferred int
	// Queued enrollments received a new command; Deduped ones already had
	// one pending and were pushed anyway; Skipped ones cannot be
	// commanded (disabled or unknown) and were completed without a push.
	Queued, Deduped, Skipped int
	// Failed enrollments had their change rows scheduled for a retry.
	Failed int
	// Pushed counts enrollments handed to the Pusher.
	Pushed int
}

type Endpoint struct {
	Op Op
	// Kind and Identifier are set for OpDeclaration only.
	Kind       schemaddm.Kind
	Identifier string
}

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

type Enqueuer interface {
	Enqueue(ctx context.Context, ids []mdm.EnrollmentID, cmd *mdm.Command, o storage.EnqueueOptions) (storage.EnqueueResult, error)
}

type EnrollmentDeclarationStatus struct {
	ID mdm.EnrollmentID
	DeclarationStatus
}

type Expander interface {
	Expand(ctx context.Context, id mdm.EnrollmentID, d *Declaration) ([]byte, error)
}

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

type NotifierConfig struct {
	Store    ChangeStore
	Tokens   TokenSource
	Enqueuer Enqueuer
	Pusher   Pusher
	Bus      *event.Bus
	Clock    clock.Clock
	Logger   *slog.Logger
	// Window defers an enrollment while its newest change is younger than
	// this, so a burst of uploads becomes one command. Default 2s.
	Window time.Duration
	// Poll is how often Run drains without a Kick. Default 1s.
	Poll time.Duration
	// Batch bounds the change rows read per drain. Default 500.
	Batch int
	// Backoff maps the attempt count to the retry delay. Default
	// storage.NotNowBackoff.
	Backoff func(attempt int) time.Duration
	// DedupeKey suppresses a new DeclarativeManagement while one is still
	// pending for the same enrollment. Nil uses DefaultDedupeKey; an empty
	// string turns suppression off, so every drain queues a command.
	//
	// It is a pointer for the same reason service.Config.ValidateTargets is:
	// the zero value has to mean "not set" so that "" can mean "off".
	// Whether to suppress is the consumer's decision, not this package's.
	DedupeKey *string
	// OnDrain, when set, is called with the outcome of every drain. A
	// suppressed command is counted in DrainResult.Deduped and is otherwise
	// invisible, which is the whole problem with suppression: it has to be
	// observable to be defensible.
	OnDrain func(ctx context.Context, res DrainResult)
}

type Op int

type Pusher interface {
	Notify(ctx context.Context, ids []mdm.EnrollmentID) (map[mdm.EnrollmentID]push.Result, error)
}

type Resolver interface {
	Resolve(ctx context.Context, id mdm.EnrollmentID) ([]string, error)
}

type Response struct {
	Body []byte
	// Status is 200, or 404 when a declaration is not part of the
	// enrollment's manifest (Apple: the device then removes it).
	Status int
}

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

type Set struct {
	Name      string
	CreatedAt time.Time
	UpdatedAt time.Time
}

type SetStore interface {
	// PutSet creates the set; created is false when it already existed.
	PutSet(ctx context.Context, name string, at time.Time) (created bool, err error)
	// DeleteSet removes the set, its memberships, and its assignments.
	DeleteSet(ctx context.Context, name string) error
	GetSet(ctx context.Context, name string) (*Set, error)
	ListSets(ctx context.Context, p storage.Page) (storage.Result[Set], error)
	// AddSetDeclaration returns ErrNotFound when either side is unknown.
	AddSetDeclaration(ctx context.Context, set, identifier string, at time.Time) (changed bool, err error)
	RemoveSetDeclaration(ctx context.Context, set, identifier string) (changed bool, err error)
	// SetDeclarations lists member identifiers, sorted; ErrNotFound for an
	// unknown set.
	SetDeclarations(ctx context.Context, set string) ([]string, error)
	// DeclarationSets lists the sets containing identifier, sorted.
	DeclarationSets(ctx context.Context, identifier string) ([]string, error)
}

type Snapshot struct {
	ID                mdm.EnrollmentID
	DeclarationsToken string
	Items             []SnapshotItem
	TokenChangedAt    time.Time
	RefreshedAt       time.Time
}

type SnapshotItem struct {
	DeclarationRef
	// BaseToken is the stored declaration's token; ServerToken differs only
	// when an Expander rewrote the bytes for this enrollment.
	BaseToken string
	// Expanded holds the per-enrollment canonical bytes when they differ
	// from the stored declaration; nil otherwise.
	Expanded []byte
}

type SnapshotStore interface {
	// PutSnapshot replaces the snapshot and its items atomically.
	PutSnapshot(ctx context.Context, s *Snapshot) error
	Snapshot(ctx context.Context, id mdm.EnrollmentID) (*Snapshot, error)
}

type StatusError struct {
	Seq        int64
	StatusItem string
	Reasons    []byte
	ReceivedAt time.Time
}

type StatusOutcome struct {
	Seq           int64
	Removed       []DeclarationRef
	RemovedValues []string
	PrunedReports int64
}

type StatusReportRecord struct {
	Seq        int64
	FullReport bool
	Raw        []byte
	ReceivedAt time.Time
}

type StatusStore interface {
	// PutStatus applies one report atomically: appends the raw report,
	// upserts declaration rows and values (LastSeen bumped, FirstSeen kept),
	// appends errors, and for a full report deletes declaration rows and
	// values absent from the update. It prunes raw reports beyond
	// KeepReports, oldest first.
	PutStatus(ctx context.Context, id mdm.EnrollmentID, u StatusUpdate) (StatusOutcome, error)
	// DeclarationStatus lists rows sorted by (kind, identifier).
	DeclarationStatus(ctx context.Context, id mdm.EnrollmentID) ([]DeclarationStatus, error)
	DeclarationStatusByIdentifier(ctx context.Context, identifier string, p storage.Page) (storage.Result[EnrollmentDeclarationStatus], error)
	// StatusValues pages by path.
	StatusValues(ctx context.Context, id mdm.EnrollmentID, q StatusValueQuery, p storage.Page) (storage.Result[StatusValue], error)
	// StatusErrors pages newest first.
	StatusErrors(ctx context.Context, id mdm.EnrollmentID, p storage.Page) (storage.Result[StatusError], error)
	// StatusReports pages newest first.
	StatusReports(ctx context.Context, id mdm.EnrollmentID, p storage.Page) (storage.Result[StatusReportRecord], error)
}

type StatusUpdate struct {
	Raw        []byte
	ReceivedAt time.Time
	FullReport bool
	// HasDeclarations is false when the report carried no
	// management.declarations item, in which case declaration rows are
	// left untouched even for a full report.
	HasDeclarations bool
	Declarations    []DeclarationStatus
	Values          []StatusValue
	Errors          []StatusError
	// KeepReports bounds the raw reports retained per enrollment.
	KeepReports int
}

type StatusValue struct {
	Path      string
	Value     []byte
	FirstSeen time.Time
	LastSeen  time.Time
}

type StatusValueQuery struct {
	PathPrefix string
}

type Store interface {
	Tx
	// Update runs fn in one transaction; an error rolls everything back.
	Update(ctx context.Context, fn func(tx Tx) error) error
}

type Subscriptions struct {
	Enabled bool
	// Baseline is used until a device reports its capabilities; nil means
	// DefaultSubscriptionBaseline.
	Baseline []string
	// Exclude drops reported status items with these prefixes; nil means
	// DefaultSubscriptionExclude.
	Exclude []string
}

type TokenSource interface {
	Tokens(ctx context.Context, id mdm.EnrollmentID) ([]byte, error)
}

type Tx interface {
	DeclarationStore
	SetStore
	AssignmentStore
	SnapshotStore
	StatusStore
	ChangeStore
	// ClearEnrollment deletes the enrollment's sets, assignments, snapshot,
	// status, and pending changes. Absent state is not an error.
	ClearEnrollment(ctx context.Context, id mdm.EnrollmentID) error
}