cache

type Cache[ENT any, ID comparable] struct {
	// Source is the location of the original data
	Source Source[ENT, ID]
	// Repository is the resource that keeps the cached data.
	Repository Repository[ENT, ID]
	// IDA [optional] is the ENT's ID accessor.
	//
	// default: extid Lookup/Set
	IDA extid.Accessor[ENT, ID]

	CachedQueryInvalidators []CachedQueryInvalidator[ENT, ID]
}

type CachedQueryInvalidator[ENT, ID any] struct {
	// CheckEntity checks an entity which is being invalidated, and using its properties,
	// you can construct the entity values
	CheckEntity func(ent ENT) []HitID
	// CheckHit meant to check a Hit to decide if it needs to be invalidated.
	// If CheckHit returns with true, then the hit will be invalidated.
	CheckHit func(hit Hit[ID]) bool
}

type EntityRepository[ENT, ID any] interface {
	crud.Creator[ENT]
	crud.Updater[ENT]
	crud.Finder[ENT, ID]
	crud.Deleter[ID]
	crud.ByIDsFinder[ENT, ID]
	crud.Saver[ENT]
}

type Hit[ID any] struct {
	ID        HitID `ext:"id"`
	EntityIDs []ID
	Timestamp time.Time
}

type HitID string

type HitRepository[EntID any] interface {
	crud.Saver[Hit[EntID]]
	crud.Finder[Hit[EntID], HitID]
	crud.Deleter[HitID]
}

type Interface[ENT, ID any] interface {
	CachedQueryOne(ctx context.Context, hid HitID, query QueryOneFunc[ENT]) (_ent ENT, _found bool, _err error)
	CachedQueryMany(ctx context.Context, hid HitID, query QueryManyFunc[ENT]) (iterators.Iterator[ENT], error)
	InvalidateCachedQuery(ctx context.Context, hid HitID) error
	InvalidateByID(ctx context.Context, id ID) (rErr error)
	DropCachedValues(ctx context.Context) error
}

type Query struct {
	// Name is the name of the repository's query operation.
	// A method name or any unique deterministic name is sufficient.
	Name constant.String
	// ARGS contain parameters to the query that can affect the query result.
	// Supplying the ARGS ensures that a query call with different arguments cached individually.
	// Request lifetime related values are not expected to be part of ARGS.
	// ARGS should contain values that are serializable.
	ARGS QueryARGS
	// Version can help supporting multiple version of the same cached operation,
	// so if the application rolls out with a new version, that has different behaviour or fifferend signature
	// these values can be distringuesed
	Version int
}

type QueryARGS map[string]any

type QueryManyFunc[ENT any] func() (iterators.Iterator[ENT], error)

type QueryOneFunc[ENT any] func() (_ ENT, found bool, _ error)

type Repository[ENT, ID any] interface {
	comproto.OnePhaseCommitProtocol
	Entities() EntityRepository[ENT, ID]
	Hits() HitRepository[ID]
}

type Source[ENT, ID any] interface {
	crud.ByIDFinder[ENT, ID]
}