/*
 *  Copyright 2019 Anyware Services
 *
 *  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 org.ametys.core.cache;

import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

import org.slf4j.Logger;

import org.ametys.runtime.i18n.I18nizableText;

/**
 * A cache represents a store of objects indexed with a key
 * @param <K> the type of the keys in cache
 * @param <V> the type of the values in cache
 */
public interface Cache<K, V>
{
    /**
     * Returns the value associated with {@code key} in this cache if it exist,
     * obtaining that value from given function if necessary and store it.
     * @param key the key to get the element
     * @param function the function to compute the value if key is not present
     * @return V the value associated with key
     * @throws CacheException throw CacheException if the key is null or invalid, or if failed to compute the new value
     */
    public V get(K key, Function<K, V> function) throws CacheException;

    /**
     * Returns the value associated with {@code key} in this cache if it exist
     * @param key the key to get the element
     * @return V the value linked to key
     */
    public V get(K key);
    
    /**
     * Associates {@code value} with {@code key} in this cache. If the cache
     * previously contained a value associated with {@code key}, the old value
     * is replaced by {@code value}. The {@code key} can not be null.
     * @param key the key to get the element
     * @param value the value associated with key
     */
    public void put(K key, V value);

    /**
     * Copies all of the mappings from the specified map to the cache.
     * @param map map of key/values to be stored in the cache
     */
    public void putAll(Map<K, V> map);

    /**
     * return true if key is present in cache
     * @param key the key to be checked
     * @return true if key is present in cache
     */
    public boolean hasKey(K key);

    /**
     * Discards any cached value for key {@code key}.
     * @param key the key to invalidate
     */
    public void invalidate(K key);

    /**
     * Discards all entries in the cache, without reseting statistics
     */
    public void invalidateAll();

    /**
     * Create or reset the whole cache (including statistics)
     */
    public void resetCache();

    /**
     * Get all statistics about cache
     * @return statistic about the cache (hit, miss, evictions...)
     */
    public CacheStats getCacheStats();

    /**
     * Get the size the cache take in bytes
     * @return the size of the cache if it's computable, return 0 otherwise
     * @throws CacheException throw CacheException if memory size can not be computed
     */
    public long getMemorySize() throws CacheException;

    /**
     * Get the max size allocated to the cache, in bytes. 
     * This value can be set to Long.MAX_VALUE for infinite cache
     * @return the max size allocated to the cache
     */
    public long getMaxSize();

    /**
     * Get the number of values in cache
     * @return the number of values in cache
     */
    public long getNumberOfElements();

    /**
     * Get the label of cache
     * @return the label of cache
     */
    public I18nizableText getLabel();

    /**
     * Get the description of cache
     * @return the description of cache
     */
    public I18nizableText getDescription();

    /**
     * Get the id of cache
     * @return the id of cache
     */
    public String getId();

    /**
     * Is this cache size computable
     * @return true if the cache size is computable
     */
    public boolean isComputableSize();

    /**
     * Get the cache as a simple Map
     * @return the Map&lt;K, V&gt; representing the cache
     */
    public Map<K, V> asMap();
    
    /**
     * Get the definition in JSON Map
     * @param logger Logger to log an error when the size cannot be computed
     * @return the JSON for the cache
     */
    public default Map<String, Object> toJSONMap(Logger logger)
    {
        Map<String, Object> properties = new HashMap<>();
        properties.put("id", this.getId());
        properties.put("label", this.getLabel());
        properties.put("description", this.getDescription());
        properties.put("computableSize", this.isComputableSize());
        properties.put("access", this.getCacheStats().requestCount());
        properties.put("hit", this.getCacheStats().hitCount());
        properties.put("hitRate", this.getCacheStats().hitRate());
        properties.put("miss", this.getCacheStats().missCount());
        properties.put("missRate", this.getCacheStats().missRate());
        properties.put("nbElement", this.getNumberOfElements());
        properties.put("nbEviction", this.getCacheStats().evictionCount());
        try
        {
            properties.put("currentSize", this.getMemorySize());
        }
        catch (CacheException e)
        {
            logger.error("Unable to compute size of cache: {} - {}", this.getId(), this.getLabel(), e);
            properties.put("currentSize", -1);
        }
        properties.put("maxSize", this.getMaxSize());
        return properties;
    }

}