/*
Copyright 2014 The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package cache

import (
	"errors"
	"fmt"
	"strings"

	"k8s.io/apimachinery/pkg/api/meta"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

// Store is a generic object storage and processing interface.  A
// Store holds a map from string keys to accumulators, and has
// operations to add, update, and delete a given object to/from the
// accumulator currently associated with a given key.  A Store also
// knows how to extract the key from a given object, so many operations
// are given only the object.
//
// In the simplest Store implementations each accumulator is simply
// the last given object, or empty after Delete, and thus the Store's
// behavior is simple storage.
//
// Reflector knows how to watch a server and update a Store.  This
// package provides a variety of implementations of Store.
type Store interface {

	// Add adds the given object to the accumulator associated with the given object's key
	Add(obj interface{}) error

	// Update updates the given object in the accumulator associated with the given object's key
	Update(obj interface{}) error

	// Delete deletes the given object from the accumulator associated with the given object's key
	Delete(obj interface{}) error

	// List returns a list of all the currently non-empty accumulators
	List() []interface{}

	// ListKeys returns a list of all the keys currently associated with non-empty accumulators
	ListKeys() []string

	// LastStoreSyncResourceVersion returns the latest resource version that the store has seen.
	// This is used to determine the latest resource version the store has seen from objects
	// observed being written to the store.
	LastStoreSyncResourceVersion() string

	// Bookmark observes a new resource version passed into it and
	// will be used to get the latest resource version of the store.
	Bookmark(rv string)

	// Get returns the accumulator associated with the given object's key
	Get(obj interface{}) (item interface{}, exists bool, err error)

	// GetByKey returns the accumulator associated with the given key
	GetByKey(key string) (item interface{}, exists bool, err error)

	// Replace will delete the contents of the store, using instead the
	// given list. Store takes ownership of the list, you should not reference
	// it after calling this function.
	Replace([]interface{}, string) error

	// Resync is meaningless in the terms appearing here but has
	// meaning in some implementations that have non-trivial
	// additional behavior (e.g., DeltaFIFO).
	Resync() error
}

// TransactionType defines the type of a transaction operation. It is used to indicate whether
// an object is being added, updated, or deleted.
type TransactionType string

const (
	TransactionTypeAdd    TransactionType = "Add"
	TransactionTypeUpdate TransactionType = "Update"
	TransactionTypeDelete TransactionType = "Delete"
)

// Transaction represents a single operation or event in a process. It holds a generic Object
// associated with the transaction and a Type indicating the kind of transaction being performed.
type Transaction struct {
	Object interface{}
	Type   TransactionType
}

type TransactionStore interface {
	// Transaction allows multiple operations to occur within a single lock acquisition to
	// ensure progress can be made when there is contention.
	Transaction(txns ...Transaction) *TransactionError
}

var _ error = &TransactionError{}

type TransactionError struct {
	SuccessfulIndices []int
	TotalTransactions int
	Errors            []error
}

func (t *TransactionError) Error() string {
	return fmt.Sprintf("failed to execute (%d/%d) transactions failed due to: %v",
		t.TotalTransactions-len(t.SuccessfulIndices), t.TotalTransactions, t.Errors)
}

// KeyFunc knows how to make a key from an object. Implementations should be deterministic.
type KeyFunc func(obj interface{}) (string, error)

// KeyError will be returned any time a KeyFunc gives an error; it includes the object
// at fault.
type KeyError struct {
	Obj interface{}
	Err error
}

// Error gives a human-readable description of the error.
func (k KeyError) Error() string {
	return fmt.Sprintf("couldn't create key for object %+v: %v", k.Obj, k.Err)
}

// Unwrap implements errors.Unwrap
func (k KeyError) Unwrap() error {
	return k.Err
}

// ExplicitKey can be passed to MetaNamespaceKeyFunc if you have the key for
// the object but not the object itself.
type ExplicitKey string

// MetaNamespaceKeyFunc is a convenient default KeyFunc which knows how to make
// keys for API objects which implement meta.Interface.
// The key uses the format <namespace>/<name> unless <namespace> is empty, then
// it's just <name>.
//
// Clients that want a structured alternative can use ObjectToName or MetaObjectToName.
// Note: this would not be a client that wants a key for a Store because those are
// necessarily strings.
//
// TODO maybe some day?: change Store to be keyed differently
func MetaNamespaceKeyFunc(obj interface{}) (string, error) {
	if key, ok := obj.(ExplicitKey); ok {
		return string(key), nil
	}
	objName, err := ObjectToName(obj)
	if err != nil {
		return "", err
	}
	return objName.String(), nil
}

// ObjectToName returns the structured name for the given object,
// if indeed it can be viewed as a metav1.Object.
func ObjectToName(obj interface{}) (ObjectName, error) {
	meta, err := meta.Accessor(obj)
	if err != nil {
		return ObjectName{}, fmt.Errorf("object has no meta: %v", err)
	}
	return MetaObjectToName(meta), nil
}

// MetaObjectToName returns the structured name for the given object
func MetaObjectToName(obj metav1.Object) ObjectName {
	if len(obj.GetNamespace()) > 0 {
		return ObjectName{Namespace: obj.GetNamespace(), Name: obj.GetName()}
	}
	return ObjectName{Namespace: "", Name: obj.GetName()}
}

// SplitMetaNamespaceKey returns the namespace and name that
// MetaNamespaceKeyFunc encoded into key.
//
// TODO: replace key-as-string with a key-as-struct so that this
// packing/unpacking won't be necessary.
func SplitMetaNamespaceKey(key string) (namespace, name string, err error) {
	parts := strings.Split(key, "/")
	switch len(parts) {
	case 1:
		// name only, no namespace
		return "", parts[0], nil
	case 2:
		// namespace and name
		return parts[0], parts[1], nil
	}

	return "", "", fmt.Errorf("unexpected key format: %q", key)
}

// `*cache` implements Indexer in terms of a ThreadSafeStore and an
// associated KeyFunc.
type cache struct {
	// cacheStorage bears the burden of thread safety for the cache
	cacheStorage ThreadSafeStore
	// keyFunc is used to make the key for objects stored in and retrieved from items, and
	// should be deterministic.
	keyFunc KeyFunc
	// Called with every object put in the cache.
	transformer TransformFunc
	// identifier is used to identify the store for metrics.
	identifier InformerNameAndResource
	// metrics is the metrics provider for the store.
	metrics InformerMetricsProvider
}

var _ Store = &cache{}

func (c *cache) Transaction(txns ...Transaction) *TransactionError {
	txnStore, ok := c.cacheStorage.(ThreadSafeStoreWithTransaction)
	if !ok {
		return &TransactionError{
			TotalTransactions: len(txns),
			Errors: []error{
				errors.New("transaction not supported"),
			},
		}
	}
	keyedTxns := make([]ThreadSafeStoreTransaction, 0, len(txns))
	successfulIndices := make([]int, 0, len(txns))
	errs := make([]error, 0)
	for i := range txns {
		txn := txns[i]
		key, err := c.keyFunc(txn.Object)
		if err != nil {
			errs = append(errs, KeyError{txn.Object, err})
			continue
		}
		successfulIndices = append(successfulIndices, i)
		keyedTxns = append(keyedTxns, ThreadSafeStoreTransaction{txn, key})
	}
	txnStore.Transaction(keyedTxns...)
	if len(errs) > 0 {
		return &TransactionError{
			SuccessfulIndices: successfulIndices,
			TotalTransactions: len(txns),
			Errors:            errs,
		}
	}
	return nil
}

// Add inserts an item into the cache.
func (c *cache) Add(obj interface{}) error {
	key, err := c.keyFunc(obj)
	if err != nil {
		return KeyError{obj, err}
	}
	if c.transformer != nil {
		obj, err = c.transformer(obj)
		if err != nil {
			return fmt.Errorf("transforming: %w", err)
		}
	}
	c.cacheStorage.Add(key, obj)
	return nil
}

// Update sets an item in the cache to its updated state.
func (c *cache) Update(obj interface{}) error {
	key, err := c.keyFunc(obj)
	if err != nil {
		return KeyError{obj, err}
	}
	if c.transformer != nil {
		obj, err = c.transformer(obj)
		if err != nil {
			return fmt.Errorf("transforming: %w", err)
		}
	}
	c.cacheStorage.Update(key, obj)
	return nil
}

// Delete removes an item from the cache.
func (c *cache) Delete(obj interface{}) error {
	key, err := c.keyFunc(obj)
	if err != nil {
		return KeyError{obj, err}
	}
	c.cacheStorage.DeleteWithObject(key, obj)
	return nil
}

// List returns a list of all the items.
// List is completely threadsafe as long as you treat all items as immutable.
func (c *cache) List() []interface{} {
	return c.cacheStorage.List()
}

// ListKeys returns a list of all the keys of the objects currently
// in the cache.
func (c *cache) ListKeys() []string {
	return c.cacheStorage.ListKeys()
}

func (c *cache) LastStoreSyncResourceVersion() string {
	return c.cacheStorage.LastStoreSyncResourceVersion()
}

func (c *cache) Bookmark(rv string) {
	c.cacheStorage.Bookmark(rv)
}

// GetIndexers returns the indexers of cache
func (c *cache) GetIndexers() Indexers {
	return c.cacheStorage.GetIndexers()
}

// Index returns a list of items that match on the index function
// Index is thread-safe so long as you treat all items as immutable
func (c *cache) Index(indexName string, obj interface{}) ([]interface{}, error) {
	return c.cacheStorage.Index(indexName, obj)
}

// IndexKeys returns the storage keys of the stored objects whose set of
// indexed values for the named index includes the given indexed value.
// The returned keys are suitable to pass to GetByKey().
func (c *cache) IndexKeys(indexName, indexedValue string) ([]string, error) {
	return c.cacheStorage.IndexKeys(indexName, indexedValue)
}

// ListIndexFuncValues returns the list of generated values of an Index func
func (c *cache) ListIndexFuncValues(indexName string) []string {
	return c.cacheStorage.ListIndexFuncValues(indexName)
}

// ByIndex returns the stored objects whose set of indexed values
// for the named index includes the given indexed value.
func (c *cache) ByIndex(indexName, indexedValue string) ([]interface{}, error) {
	return c.cacheStorage.ByIndex(indexName, indexedValue)
}

func (c *cache) AddIndexers(newIndexers Indexers) error {
	return c.cacheStorage.AddIndexers(newIndexers)
}

// Get returns the requested item, or sets exists=false.
// Get is completely threadsafe as long as you treat all items as immutable.
func (c *cache) Get(obj interface{}) (item interface{}, exists bool, err error) {
	key, err := c.keyFunc(obj)
	if err != nil {
		return nil, false, KeyError{obj, err}
	}
	return c.GetByKey(key)
}

// GetByKey returns the request item, or exists=false.
// GetByKey is completely threadsafe as long as you treat all items as immutable.
func (c *cache) GetByKey(key string) (item interface{}, exists bool, err error) {
	item, exists = c.cacheStorage.Get(key)
	return item, exists, nil
}

// Replace will delete the contents of 'c', using instead the given list.
// 'c' takes ownership of the list, you should not reference the list again
// after calling this function.
func (c *cache) Replace(list []interface{}, resourceVersion string) error {
	items := make(map[string]interface{}, len(list))
	for _, item := range list {
		key, err := c.keyFunc(item)
		if err != nil {
			return KeyError{item, err}
		}

		if c.transformer != nil {
			item, err = c.transformer(item)
			if err != nil {
				return fmt.Errorf("transforming: %w", err)
			}
		}
		items[key] = item
	}
	c.cacheStorage.Replace(items, resourceVersion)
	return nil
}

// Resync is meaningless for one of these
func (c *cache) Resync() error {
	return nil
}

type StoreOption = func(*cache)

func WithTransformer(transformer TransformFunc) StoreOption {
	return func(c *cache) {
		c.transformer = transformer
	}
}

func WithStoreMetrics(identifier InformerNameAndResource, metrics InformerMetricsProvider) StoreOption {
	return func(c *cache) {
		c.identifier = identifier
		c.metrics = metrics
	}
}

// NewStore returns a Store implemented simply with a map and a lock.
func NewStore(keyFunc KeyFunc, opts ...StoreOption) Store {
	c := &cache{
		keyFunc: keyFunc,
	}
	for _, opt := range opts {
		opt(c)
	}
	threadSafeOpts := []ThreadSafeStoreOption{}
	if c.metrics != nil {
		threadSafeOpts = append(threadSafeOpts, WithThreadSafeStoreMetrics(c.identifier, c.metrics))
	}
	c.cacheStorage = NewThreadSafeStore(Indexers{}, Indices{}, threadSafeOpts...)
	return c
}

// NewIndexer returns an Indexer implemented simply with a map and a lock.
func NewIndexer(keyFunc KeyFunc, indexers Indexers, opts ...StoreOption) Indexer {
	c := &cache{
		keyFunc: keyFunc,
	}
	for _, opt := range opts {
		opt(c)
	}
	threadSafeOpts := []ThreadSafeStoreOption{}
	if c.metrics != nil {
		threadSafeOpts = append(threadSafeOpts, WithThreadSafeStoreMetrics(c.identifier, c.metrics))
	}
	c.cacheStorage = NewThreadSafeStore(indexers, Indices{}, threadSafeOpts...)
	return c
}
