cache

type Attribute struct {
	Id    int
	Name  string
	Value string
}

type AutoCacheManager struct {
	Ps CacheStorage
}

type CacheManager interface {
	//set values to cache
	//SetCache(cacheKey string, cacheVal interface{}, ttl int) int
	SetCache(cacheRegistry ...CacheRegistry) error

	//recover value from cache
	//GetCache(cacheKey string) (interface{}, bool, int)
	GetCache(cacheKey string) (CacheRegistry, error)

	//recover value from cache
	//GetCache(cacheKey string) (interface{}, bool, int)
	GetCaches(cacheKey ...string) (map[string]CacheRegistry, error)

	//Invalidate cache registry. Means that this cache registry is not valid or consistent anymore.
	//Do not means that registry was deleted in original data source. This operation don't update parent registries,
	//removing references to this registry. Parent cache search must fail to find this registry,
	//meaning that all cache registry is inconsistent.
	//To represent a delete operation, updating parent registries, use exclusively the DeleteCache operation in UpdaterCacheManager interface.
	Invalidate(cacheKey ...string) error

	//validate readiness of cache operation
	Validade() bool
}

type CacheRegistry struct {
	CacheKey  string      //unique key in cache
	Payload   interface{} //payload to be cached, usually an byte array
	StoreTTL  float64     // Cache Time to Live duration
	CacheTime time.Time   //date when cache registry was created
	HasValue  bool        //return the presence of cached value on cache storage. Useful in batch operations and to avoid nil errors
	TypeName  string      //type name of payload. Only serializer implementation can see this attribute
}

type CacheStorage interface {
	//include cache registries
	SetValues(values ...CacheRegistry) error

	//recover cache values (map of values, map of hasValue bool, map of ttls, error)
	//GetValues(keys ...string) (map[string]interface{}, map[string]bool, map[string]int, error)
	GetValuesMap(keys ...string) (map[string]CacheRegistry, error)

	//delete cache values
	DeleteValues(cacheKey ...string) error
}

type Cacheable interface {
	GetCacheKey() string
}

type Car struct {
	CarId      int               `json:"carId"`
	CarName    string            `json:"carName"`
	Attributes []Attribute       `json:"specializations,omitempty"`
	FlagMap    map[string]string `json:"flagMap"`
	Ttl        int               `json:"-"`
}

type ExposeTTL interface {
	//teste
	GetTtl() float64
	SetTtl(float64) interface{}
}

type RedisCacheStorage struct {
	Serializer Serializer // usually SerializerGOB implementation
	// contains filtered or unexported fields
}

type Serializer interface {

	//register the type for future reference
	Register(sample interface{})

	// MarshalMsg implements msgp.Marshaler
	MarshalMsg(src CacheRegistry, b []byte) (o []byte, err error)

	// UnmarshalMsg implements msgp.Unmarshaler
	UnmarshalMsg(dest CacheRegistry, bts []byte) (resp interface{}, o []byte, err error)

	//prefix for this serializer, enable multiple serializer at same respository (redis)
	GetPrefix() string
}

type SerializerGOB struct {
}

type SimpleCacheManager struct {
	CacheStorage CacheStorage
}

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

type UpdateCachedRelated interface {
	//who is my parent
	ParentsKey() []string

	//For delete operation
	RemoveFromParent(interface{}) interface{}

	//For insert operations
	InsertInParent(interface{}) interface{}
}

type UpdaterCacheManager interface {
	CacheManager // import all CacheManager definitions
	//Means that cache registry was deleted on the source, and that parent registries must be updated.
	DeleteCache(cacheRegistry CacheRegistry)
}