kv

type Binary interface {
	encoding.BinaryMarshaler
	encoding.BinaryUnmarshaler
}

type Bytes interface {
	~[]byte | ~string
}

type Codec[V any] interface {
	// Marshal encodes a Go value to a slice of bytes.
	Marshal(v V) ([]byte, error)
	// Unmarshal decodes a slice of bytes into a Go value.
	Unmarshal(data []byte, v *V) error
}

type CodecBinary[V encoding.BinaryMarshaler, VP binaryPointer[V]] struct{}

type CodecBytes[V Bytes] struct{}

type CodecGob[V any] struct{}

type CodecJSON[V any] struct{}

type Edit[V any] func(ctx context.Context, v V) (V, error)

type Iter[K, V any] func(k K, v V) error

type Locks[K any] interface {
	Lock(ctx context.Context, key K) error
	Unlock(ctx context.Context, key K) error

	// closing lock storage and releasing all locks
	Close(ctx context.Context) error
}

type Order[K any] struct {
	Min     K
	Max     K
	Reverse bool
}

type Store[K any, V any] interface {
	// Set stores the given value for the given key.
	// The implementation automatically marshalls the value.
	// The marshalling format depends on the implementation. It can be JSON, gob, etc.
	Set(ctx context.Context, k K, v V) error

	// Get retrieves the value for the given key.
	// The implementation automatically unmarshalls the value.
	// The unmarshalling source depends on the implementation. It can be JSON, gob, etc.
	// The automatic unmarshalling requires a pointer to an object of the correct type
	// being passed as a parameter.
	// In the case of a struct, the Get method will populate the fields of the object
	// that the passed pointer points to with the values of the retrieved object's values.
	// If no value is found, it returns (false, nil).
	Get(ctx context.Context, k K) (V, error)

	// Delete deletes the stored value for the given key.
	// Deleting a non-existing key-value MUST NOT lead to an error.
	Delete(ctx context.Context, k K) error

	// Edit retrieves the value for the given key, calls the provided edit function with the value,
	Edit(ctx context.Context, k K, edit Edit[V]) error

	// Close must be called when the work with the key-value store is done.
	//
	// As the same interface is used for managing transactions, calling Close() will commit the transaction in this case.
	// Most other implementations are meant to be long-lived, so only call Close() at the very end.
	//
	// Some implementations might not need the store to be closed,
	// but as long as you work with the kv.Store interface, you never know which implementation
	// is passed to your method, so you should always call it.
	Close(ctx context.Context) error

	// Range iterates over all key-value pairs in the store and calls the provided iterator function for each pair.
	// The iterator function should return non-nil error to stop the iteration, is this case. This error will be returned by Range, its canonical to return [io.EOF]
	Range(ctx context.Context, iter Iter[K, V]) error

	// RangeWithPrefix iterates over all key-value pairs in the store that have the given prefix
	// and calls the provided iterator function for each pair.
	// The iterator function should return non-nil error to stop the iteration.
	RangeWithPrefix(ctx context.Context, prefix K, iter Iter[K, V]) error
}

type StoreOrdered[K, V any] interface {
	RangeOrdered(ctx context.Context, order Order[K], iter Iter[K, V]) error
}

type TransactionalStore[K, V any] interface {
	Transaction(update bool) (Store[K, V], error)
}