api

type ClusterReads interface {
	ListClusterMembers(ctx context.Context) ([]store.ClusterMember, error)
}

type Deps struct {
	Primary     Repo                // writes + read-after-write
	Read        Repo                // UI GETs (replica or primary)
	Commands    ResourceCommands    // write use-cases (create/patch/reconcile/delete)
	Configs     ProviderConfigStore // providerconfigs CRUD (runtime-editable config)
	KindConfigs KindConfigStore     // kind_config read (per-kind cap + resync)
	Bindings    ReactorBindingStore // reactor_bindings CRUD ("what reacts to what")
	Manifests   KindManifestStore   // kind_manifest CRUD (the CRD)
	ReadyProbe  health.Pinger       // /readyz DB ping (nil → readiness always OK)
}

type EventRepo interface {
	EmitEvent(ctx context.Context, e store.Event) error
	ListEvents(ctx context.Context, resourceID uuid.UUID, cursorAt time.Time, cursorID int64, limit int) ([]store.EventRow, error)
}

type KindConfigStore interface {
	GetKindConfig(ctx context.Context, kind model.Kind, kindVersion int) (store.KindConfig, bool, error)
	ListKindConfig(ctx context.Context) ([]store.KindConfig, error)
	UpsertKindConfig(ctx context.Context, k store.KindConfig) error
	GetDefaultProviderConfig(ctx context.Context, kind model.Kind, kindVersion int) (store.DefaultProviderConfig, bool, error)
}

type KindManifestStore interface {
	UpsertKindManifest(ctx context.Context, m model.KindManifest) (int64, error)
	GetKindManifest(ctx context.Context, kind model.Kind, kindVersion int) (model.KindManifest, bool, error)
	ListKindManifests(ctx context.Context) ([]model.KindManifest, error)
	// DeleteKindManifest removes one (kind, kindVersion) — refused (ErrKindVersionInUse)
	// if a resource or exact-version-pinned binding still references it; cascades the
	// version's provider configs. found=false = already gone (idempotent 404).
	DeleteKindManifest(ctx context.Context, kind model.Kind, kindVersion int) (found bool, deletedConfigs int64, err error)
}

type ListReads interface {
	GetChildrenByOwner(ctx context.Context, ownerID uuid.UUID, limit int) ([]store.GetChildrenByOwnerRow, error)
	GetDepsByOwner(ctx context.Context, ownerID uuid.UUID, limit int) ([]store.GetDepsByOwnerRow, error)
	GetResourcesChangedSince(ctx context.Context, arg store.GetResourcesChangedSinceParams) ([]store.GetResourcesChangedSinceRow, error)
	ListResourcesPage(ctx context.Context, arg store.ListResourcesPageParams) ([]store.ListResourcesPageRow, error)
	ListRootResourcesPage(ctx context.Context, arg store.ListRootResourcesPageParams) ([]store.ListRootResourcesPageRow, error)
	CountResourcesFiltered(ctx context.Context, arg store.CountResourcesFilteredParams) (int64, error)
	CountRootResourcesFiltered(ctx context.Context, arg store.CountRootResourcesFilteredParams) (int64, error)
	CountChildrenByReadiness(ctx context.Context, ownerID uuid.UUID) ([]store.CountChildrenByReadinessRow, error)
	CountResourcesByReadinessScoped(ctx context.Context, ownerIDs []uuid.UUID) ([]store.CountResourcesByReadinessScopedRow, error)
}

type OpsRepo interface {
	CreateOperationRow(ctx context.Context, resourceID uuid.UUID, verb string, input []byte, requestedBy string) (store.ResourceOperation, error)
	GetOperation(ctx context.Context, id uuid.UUID) (store.ResourceOperation, error)
	ListOperationsByResource(ctx context.Context, resourceID uuid.UUID, states []string, limit int) ([]store.ResourceOperation, error)
	SetOperationRunning(ctx context.Context, id uuid.UUID) error
}

type ProviderConfigStore interface {
	UpsertProviderConfig(ctx context.Context, name string, kind model.Kind, kindVersion int, isDefault bool, spec json.RawMessage, data []byte) (store.ProviderConfig, bool, error)
	GetProviderConfig(ctx context.Context, name string) (store.ProviderConfig, bool, error)
	ListProviderConfigs(ctx context.Context, f store.ProviderConfigFilter, limit, offset int) ([]store.ProviderConfig, error)
	CountProviderConfigs(ctx context.Context, f store.ProviderConfigFilter) (int64, error)
	DeleteProviderConfig(ctx context.Context, name string) (bool, error)
}

type ReactorBindingStore interface {
	UpsertReactorBinding(ctx context.Context, b store.ReactorBinding) error
	ListReactorBindings(ctx context.Context) ([]store.ReactorBinding, error)
	DeleteReactorBinding(ctx context.Context, name string) (bool, error)
}

type Repo interface {
	ResourceReads
	ListReads
	TopologyReads
	OpsRepo
	EventRepo
	ClusterReads
}

type ResourceCommands interface {
	ApplySpec(ctx context.Context, kind model.Kind, name string, spec json.RawMessage, labels map[string]string) (store.ApplyResult, error)
	// ApplySpecWithConfig is ApplySpec plus a per-resource CUSTOM config
	// attachment (the providerconfig name in provider_config_ref). Empty name
	// means "no attachment", identical to ApplySpec. (kindVersion = 1.)
	ApplySpecWithConfig(ctx context.Context, kind model.Kind, name string, spec json.RawMessage, labels map[string]string, providerConfigName string) (store.ApplyResult, error)
	// ApplySpecKindVersionWithConfig pins the web-API kindVersion on CREATE (the apply path
	// uses it so a new resource records the version it was authored against).
	ApplySpecKindVersionWithConfig(ctx context.Context, kind model.Kind, kindVersion int, name string, spec json.RawMessage, labels map[string]string, providerConfigName string) (store.ApplyResult, error)
	// ResolveResourceIDKindVersionByKindName resolves (id, current kindVersion, found) so the
	// apply path can detect a breaking kindVersion FLIP (applied kindVersion != pinned kindVersion).
	ResolveResourceIDKindVersionByKindName(ctx context.Context, kind model.Kind, name string) (uuid.UUID, int, bool, error)
	// FlipResourceKindVersion performs the uuid-stable flip: rewrite the spec to the
	// new kindVersion's shape and bump the resource's kindVersion + generation in place.
	FlipResourceKindVersion(ctx context.Context, id uuid.UUID, oldKindVersion, newKindVersion int, newSpec json.RawMessage, kind model.Kind) (store.FlipResult, error)
	Reconcile(ctx context.Context, id uuid.UUID) error
	RequestResourceDeletion(ctx context.Context, id uuid.UUID, finalizer, actor string) (bool, error)
	// QuarantineResource sets a failed/stuck resource aside (freezes it from all
	// schedulers + unblocks its root's rollup, without deleting it).
	QuarantineResource(ctx context.Context, id uuid.UUID, actor string) (bool, error)
	// UnquarantineResource clears a quarantine and re-arms the resource.
	UnquarantineResource(ctx context.Context, id uuid.UUID, actor string) (bool, error)
	// RollbackSpec checks out a historic root revision (by authored
	// generation) as the live spec, returning the resource's generation after
	// checkout (0 if the revision wasn't found).
	RollbackSpec(ctx context.Context, id uuid.UUID, generation int64, actor string) (int64, error)
}

type ResourceInfo = resourceInfo

type ResourceReads interface {
	// Public-identity resolution: (kind, name) → internal id. Every name-keyed
	// handler calls this once at its top, then delegates to the id-based reads.
	ResolveResourceIDByKindName(ctx context.Context, kind model.Kind, name string) (uuid.UUID, error)
	ResolveResourceIDsByKindName(ctx context.Context, refs []store.ObjectRef) ([]store.ResolvedRef, error)

	// Per-resource reads. The single-resource reads are addressed by the PUBLIC
	// (kind, name) and fold the id-resolve into the query itself (one indexed
	// seek, no separate probe); GetResource returns r.id for the detail
	// handler's own follow-ups (conditions, work_queue). GetResourceInfo stays
	// id-based for the internal paths that already hold an id (apply read-back,
	// owner-cache batch); GetResourceInfoByName is its (kind,name) counterpart
	// used for the owner envelope (returns r.id, reused by the scoped query).
	GetResource(ctx context.Context, kind model.Kind, name string) (store.GetResourceRow, error)
	GetResourceInfo(ctx context.Context, id uuid.UUID) (store.GetResourceInfoRow, error)
	GetResourceInfoByName(ctx context.Context, kind model.Kind, name string) (store.GetResourceInfoByNameRow, error)
	GetResourcesInfo(ctx context.Context, ids []uuid.UUID) ([]store.GetResourcesInfoRow, error)
	GetResourceManifest(ctx context.Context, kind model.Kind, name string) (store.GetResourceManifestRow, error)
	GetResourceStatus(ctx context.Context, kind model.Kind, name string) (store.GetResourceStatusRow, error)

	// Spec revision history (roots): list revisions (bodies elided) + fetch
	// one historic body (by authored generation) for raw download / prefill.
	// Both addressed by (kind, name).
	ListSpecHistory(ctx context.Context, kind model.Kind, name string, limit int) ([]store.SpecHistoryRow, error)
	GetSpecRevision(ctx context.Context, kind model.Kind, name string, generation int64) (json.RawMessage, error)
	GetResourceDependencies(ctx context.Context, kind model.Kind, name string) ([]store.GetResourceDependenciesRow, error)
	ListResourceConditions(ctx context.Context, resourceID uuid.UUID) ([]store.ListResourceConditionsRow, error)
	GetWorkQueueByResource(ctx context.Context, resourceID uuid.UUID) ([]store.GetWorkQueueByResourceRow, error)
}

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

type TopologyReads interface {
	AggregateTopology(ctx context.Context, ownerID uuid.UUID, path []store.TopologyPathSegment, nextKey, cursor string, limit int) ([]store.TopologyBucket, error)
	CountTopologyBuckets(ctx context.Context, ownerID uuid.UUID, path []store.TopologyPathSegment, nextKey string) (int, error)
	TopologyLeaves(ctx context.Context, ownerID uuid.UUID, path []store.TopologyPathSegment, cursorName string, cursorID uuid.UUID, limit int) ([]store.GetChildrenByOwnerRow, error)
	TopologyLabelKeys(ctx context.Context, ownerID uuid.UUID, limit int) ([]string, error)
	SubgraphTransitive(ctx context.Context, kind model.Kind, name string, ancestorDepth, descendantDepth, limit int) ([]store.SubgraphTransitiveRow, error)
	SubgraphDeps(ctx context.Context, ids []uuid.UUID) ([]store.SubgraphDep, error)
}