package kms

import (
	"context"

	"github.com/minio/kms-go/kes"
)

// KeyManager is the generic interface that handles KMS key operations
type KeyManager interface {
	// CreateKey creates a new key at the KMS with the given key ID.
	CreateKey(ctx context.Context, keyID string) error

	// DeleteKey deletes a key at the KMS with the given key ID.
	// Please note that is a dangerous operation.

	return c.client.APIs(ctx)
}

// CreateKey tries to create a new key at the KMS with the
// given key ID.
//
// If the a key with the same keyID already exists then
// CreateKey returns kes.ErrKeyExists.
func (c *kesClient) CreateKey(ctx context.Context, keyID string) error {
	c.lock.RLock()
	defer c.lock.RUnlock()

	return c.client.CreateKey(ctx, keyID)
}

    interface PluginDescriptorSupplier {
        PluginDescriptor load()
                throws PluginResolutionException, PluginDescriptorParsingException, InvalidPluginDescriptorException;
    }

    Key createKey(Plugin plugin, List<RemoteRepository> repositories, RepositorySystemSession session);

    void put(Key key, PluginDescriptor pluginDescriptor);

    PluginDescriptor get(Key key);

        public ExtensionDescriptor getDescriptor() {
            return descriptor;
        }

        public List<Artifact> getArtifacts() {
            return artifacts;
        }
    }

    Key createKey(List<Artifact> extensionArtifacts);

    CacheRecord get(Key key);

    CacheRecord put(
            Key key, ClassRealm extensionRealm, ExtensionDescriptor extensionDescriptor, List<Artifact> artifacts);

        // marker interface for cache keys
    }

    @FunctionalInterface
    interface PluginRealmSupplier {
        CacheRecord load() throws PluginResolutionException, PluginContainerException;
    }

    Key createKey(
            Plugin plugin,
            ClassLoader parentRealm,
            Map<String, ClassLoader> foreignImports,
            DependencyFilter dependencyFilter,
            List<RemoteRepository> repositories,

        public String toString() {
            return extensionRealms.toString();
        }
    }

    protected final Map<Key, CacheRecord> cache = new ConcurrentHashMap<>();

    @Override
    public Key createKey(List<? extends ClassRealm> extensionRealms) {
        return new CacheKey(extensionRealms);
    }

    public CacheRecord get(Key key) {
        return cache.get(key);
    }

	// List returns an array of local KMS Names
	List() []kes.KeyInfo

	// Metrics returns a KMS metric snapshot.
	Metrics(ctx context.Context) (kes.Metric, error)

	// CreateKey creates a new key at the KMS with the given key ID.
	CreateKey(ctx context.Context, keyID string) error

	// GenerateKey generates a new data encryption key using the
	// key referenced by the key ID.
	//

                    && Objects.equals(filter, that.filter);
        }
    }

    protected final Map<Key, CacheRecord> cache = new ConcurrentHashMap<>();

    public Key createKey(
            Plugin plugin,
            DependencyFilter extensionFilter,
            List<RemoteRepository> repositories,
            RepositorySystemSession session) {

            throws PluginResolutionException, PluginDescriptorParsingException, InvalidPluginDescriptorException {
        PluginDescriptorCache.Key cacheKey = pluginDescriptorCache.createKey(plugin, repositories, session);

        PluginDescriptor pluginDescriptor = pluginDescriptorCache.get(cacheKey, () -> {
            org.eclipse.aether.artifact.Artifact artifact =

        CacheRecord(ClassRealm realm, DependencyFilter extensionArtifactFilter) {
            this.realm = realm;
            this.extensionArtifactFilter = extensionArtifactFilter;
        }
    }

    Key createKey(List<? extends ClassRealm> extensionRealms);

    CacheRecord get(Key key);

    CacheRecord put(Key key, ClassRealm projectRealm, DependencyFilter extensionArtifactFilter);

    void flush();

    /**