/*
 *  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.lang.ref.WeakReference;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

import org.apache.avalon.framework.CascadingRuntimeException;
import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;

import org.ametys.core.ui.Callable;
import org.ametys.plugins.core.impl.cache.GuavaCacheStats;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.runtime.request.RequestListener;
import org.ametys.runtime.request.RequestListenerManager;


/**
 * Component that handle all the caches
 */
public abstract class AbstractCacheManager extends AbstractLogEnabled implements Component, Serviceable, Contextualizable, Initializable, RequestListener
{

    /** The type of cache */
    public enum CacheType
    {
        /** A cache used for a request */
        REQUEST,
        /** A cache stored in memory */
        MEMORY
    }

    /** Role */
    public static final String ROLE = AbstractCacheManager.class.getPackageName() + ".CacheManager";

    /** Map linking id with persistent caches */
    protected Map<String, Cache> _memoryCaches = new HashMap<>();

    /** Map linking id with CacheInfo of a request cache */
    protected Map<String, CacheInfo> _requestsCacheInfos = new HashMap<>();

    /** Map linking id with CacheStats of a request cache */
    protected Map<String, CacheStats> _requestsCacheStats = new HashMap<>();

    /** HashMap linking an id with a List of WeakReference of Caches. this mean values can be destroyed by the garbage collector */
    protected Map<String, List<WeakReference<Cache>>> _requestCaches = new HashMap<>();

    /** Avalon context */
    protected Context _context;

    /** RequestListener manager */
    protected RequestListenerManager _requestListenerManager;

    @Override
    public void initialize() throws Exception
    {
        _requestListenerManager.registerListener(this);
    }
    
    
    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        _requestListenerManager = (RequestListenerManager) serviceManager.lookup(RequestListenerManager.ROLE);
    }
    

    public void requestEnded(HttpServletRequest req)
    {
        _requestsCacheInfos.keySet().forEach(id ->
        {
            Cache requestCache = req != null ? (Cache) req.getAttribute(AbstractCacheManager.ROLE + "$" + id) : null;
            if (requestCache != null)
            {
                requestCache.getId();
                CacheStats cacheStats = requestCache.getCacheStats();
                CacheStats totalCacheStats = _requestsCacheStats.get(id);
                totalCacheStats = totalCacheStats.plus(cacheStats);
                _requestsCacheStats.put(id, totalCacheStats);
            }
        });
        
    }
    
    /**
     * Called whenever a request caches' statistics need to be manually refreshed
     * @param req the processed request
     * @param id the if of the cache to refresh
     */
    public void refreshStats(Request req, String id)
    {
        Cache requestCache = req != null ? (Cache) req.getAttribute(AbstractCacheManager.ROLE + "$" + id) : null;
        if (requestCache != null)
        {
            requestCache.getId();
            CacheStats cacheStats = requestCache.getCacheStats();
            CacheStats totalCacheStats = _requestsCacheStats.get(id);
            totalCacheStats = totalCacheStats.plus(cacheStats);
            _requestsCacheStats.put(id, totalCacheStats);
        }
    }
    
    public void requestStarted(HttpServletRequest req)
    {
        // Nothing to do on start
    }
    
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }

    /**
     * Create a new cache and store it in memoryCache map if it's a MEMORY CacheType,
     * Create a CacheInfo to create the cache later otherwise
     * @param id id of the cache
     * @param name name of the cache
     * @param description description
     * @param computableSize true if the size of the cache can be computed
     * @param duration the length of time after an entry is created that it should be automatically removed. Only used for MEMORY type caches
     * @throws CacheException if a cache already exists for the id
     */
    public void createMemoryCache(String id, I18nizableText name, I18nizableText description, boolean computableSize, Duration duration) throws CacheException
    {
        _createCache(id, name, description, CacheType.MEMORY, computableSize, duration, false);
    }

    /**
     * Create a new cache and store it in memoryCache map if it's a MEMORY CacheType,
     * Create a CacheInfo to create the cache later otherwise
     * @param id id of the cache
     * @param name name of the cache
     * @param description description
     * @param isDispatchable true if the cache can be transmitted in sub-requests of DispatchGenerator
     * @throws CacheException if a cache already exists for the id
     */
    public void createRequestCache(String id, I18nizableText name, I18nizableText description, boolean isDispatchable) throws CacheException
    {
        _createCache(id, name, description, CacheType.REQUEST, false, null, isDispatchable);
    }
    
    /**
     * Create a new cache and store it in memoryCache map if it's a MEMORY CacheType,
     * Create a CacheInfo to create the cache later otherwise
     * @param id id of the cache
     * @param name name of the cache
     * @param description description
     * @param cacheType type of the cache (REQUEST or MEMORY)
     * @param computableSize true if the size of the cache can be computed
     * @param duration the length of time after an entry is created that it should be automatically removed. Only used for MEMORY type caches
     * @param isDispatchable true if the cache can be transmitted in sub-requests of DispatchGenerator
     * @throws CacheException if a cache already exists for the id
     */
    protected void _createCache(String id, I18nizableText name, I18nizableText description, CacheType cacheType, boolean computableSize, Duration duration, boolean isDispatchable) throws CacheException
    {
        if (this._memoryCaches.containsKey(id) || _requestsCacheInfos.containsKey(id))
        {
            throw new CacheException("The cache '" + id + "' already exists");
        }

        if (cacheType == CacheType.MEMORY)
        {
            Cache ametysCache = _createCache(id, name, description, computableSize, duration, false);
            _memoryCaches.put(id, ametysCache);
        }
        else
        {
            _requestsCacheInfos.put(id, new CacheInfo(name, description, isDispatchable));
            _requestsCacheStats.put(id, new GuavaCacheStats());
            synchronized (_requestCaches)
            {
                _requestCaches.put(id, new ArrayList<>());
            }
        }
    }
    
    /**
     * Remove the cache identified by the given id.
     * @param id id of the cache
     * @param cacheType type of the cache
     * @throws CacheException if the cache does not exist for the id and type
     */
    public synchronized void removeCache(String id, CacheType cacheType) throws CacheException
    {
        switch (cacheType)
        {
            case MEMORY:
                if (_memoryCaches.containsKey(id))
                {
                    _memoryCaches.remove(id);
                    return;
                }
                break;
            case REQUEST:
                if (_requestsCacheInfos.containsKey(id))
                {
                    _requestsCacheInfos.remove(id);
                    _requestCaches.remove(id);
                    _requestsCacheStats.remove(id);
                    return;
                }
                break;
            default:
                throw new IllegalStateException("Unknown CacheType " + cacheType);
        }
        
        throw new CacheException("The cache '" + id + "' does not exist");
    }

    /**
     * Get the cache by id. If it's a request cache, create it and store it in request and in _requestCaches map.
     * @param <K> the type of the keys in cache
     * @param <V> the type of the values in cache
     * @param id id of the cache
     * @return the cache related to the id
     * @throws CacheException if no cache exist for the id
     */
    @SuppressWarnings("unchecked")
    public <K, V> Cache<K, V> get(String id) throws CacheException
    {
        if (!_memoryCaches.containsKey(id) && !_requestsCacheInfos.containsKey(id))
        {
            throw new CacheException("Cache " + id + " does not exist ");
        }

        if (_memoryCaches.containsKey(id))
        {
            return _memoryCaches.get(id);
        }
        else
        {
            Request request = null;
            try
            {
                request = ContextHelper.getRequest(_context);
            }
            catch (CascadingRuntimeException e)
            {
                // Nothing... request is null
                getLogger().debug("No request available when getting cache {}", id, e);
            }

            Cache<K, V> requestCache = request != null ? (Cache<K, V>) request.getAttribute(AbstractCacheManager.ROLE + "$" + id) : null;
            if (requestCache == null)
            {
                CacheInfo cacheInfo = _requestsCacheInfos.get(id);
                requestCache = _createCache(id, cacheInfo.getName(), cacheInfo.getDescription(), false, null, cacheInfo.isDispatchable());
                synchronized (_requestCaches)
                {
                    _requestCaches.get(id).add(new WeakReference<>(requestCache));
                }
                if (request != null)
                {
                    request.setAttribute(AbstractCacheManager.ROLE + "$" + id, requestCache);
                }
            }

            return requestCache;
        }
    }
    
    /**
     * Get all the memory caches identified by Id
     * @return all memory caches
     */
    public List<Cache> getAllMemoryCaches()
    {
        return new ArrayList<>(_memoryCaches.values());
    }

    /**
     * Get all caches classified by Identifier and CacheType. All caches includes all running request caches in any existing request.
     * @return all cache
     */
    public Map<Pair<String, CacheType>, List<Cache>> getAllCaches()
    {
        Map<Pair<String, CacheType>, List<Cache>> caches = new HashMap<>();

        _memoryCaches.forEach((id, cache) -> caches.put(Pair.of(id, CacheType.MEMORY), Collections.singletonList(cache)));

        // clean weak references
        synchronized (_requestCaches)
        {
            // Clean the list of destroyed request
            _requestCaches.forEach((id, cacheList) -> _requestCaches.put(id, cacheList.stream().filter(wr -> wr.get() != null).collect(Collectors.toList())));
            
            _requestCaches.forEach((id, cacheList) -> caches.put(Pair.of(id, CacheType.REQUEST), cacheList.stream().map(wr -> wr.get()).collect(Collectors.toList())));
        }
        
        return caches;
    }

    /**
     * Get list of memory caches in JSON format
     * @return the memory caches in JSON format
     */
    @Callable (rights = "Runtime_Rights_Admin_Access", context = "/admin")
    public List<Map<String, Object>> getCachesAsJSONMap()
    {
        List<Map<String, Object>> properties = new ArrayList<>();
        _memoryCaches.forEach((k, v) ->
        {
            properties.add(v.toJSONMap(getLogger()));
        });
        _requestsCacheStats.forEach((k, v) ->
        {
            properties.add(this.toJSONMap(k, _requestsCacheInfos.get(k), v));
        });
        return properties;
    }
    
    /**
     * Returns true if the cache with given id exists
     * @param id id of the cache
     * @return true if the cache with given id exists
     */
    public boolean hasCache(String id)
    {
        return _memoryCaches.containsKey(id) || _requestsCacheInfos.containsKey(id);
    }

    /**
     * set new max size to the cache related to given id
     * @param id the id of cache
     * @param size the size of the cache in bytes
     * @return true if success
     * @throws CacheException throw CacheException if the key is null or invalid
     * @throws UnsupportedOperationException not implemented yet
     */
    @Callable (rights = "Runtime_Rights_Admin_Access", context = "/admin")
    public boolean setSize(String id, long size) throws CacheException, UnsupportedOperationException
    {
        throw new UnsupportedOperationException("NOT IMPLEMENTED YET");
    }

    /**
     * Create a new cache
     * @param <K> Key type of the cache
     * @param <V> Value type of the cache
     * @param id the id of the cache
     * @param name the name of the cache
     * @param description the description of the cache
     * @param computableSize true if the size of the cache can be computed
     * @param duration the length of time after an entry is created that it should be automatically removed
     * @param isDispatchable true if the cache can be transmitted in sub-requests of DispatchGenerator
     * @return new cache
     */
    protected abstract <K, V> Cache<K, V> _createCache(String id, I18nizableText name, I18nizableText description, boolean computableSize, Duration duration, boolean isDispatchable);

    /**
     * Encapsulation of name and description of a cache
     */
    protected static final class CacheInfo
    {

        private I18nizableText _name;

        private I18nizableText _description;

        private boolean _isDispatchable;
        
        /**
         * Create new CacheInfo with name and description
         * @param name the name of the CacheInfo
         * @param description the description of the CacheInfo
         * @param isDispatchable true if the cache can be transmitted in sub-requests of DispatchGenerator
         */
        public CacheInfo(I18nizableText name, I18nizableText description, boolean isDispatchable)
        {
            _name = name;
            _description = description;
            _isDispatchable = isDispatchable;
        }

        /**
         * Get the name of the CacheInfo
         * @return the name of the CacheInfo
         */
        public I18nizableText getName()
        {
            return _name;
        }

        /**
         * Get the description of the CacheInfo
         * @return the description of the CacheInfo
         */
        public I18nizableText getDescription()
        {
            return _description;
        }
        
        /**
         * Can the cache be transmitted in sub-requests of DispatchGenerator
         * @return true if the cache can be transmitted in sub-requests of DispatchGenerator
         */
        public boolean isDispatchable()
        {
            return _isDispatchable;
        }

    }
    
    private Map<String, Object> toJSONMap(String id, CacheInfo cacheInfo, CacheStats cacheStats)
    {
        Map<String, Object> properties = new HashMap<>();
        properties.put("id", id);
        properties.put("label", cacheInfo.getName());
        properties.put("description", cacheInfo.getDescription());
        properties.put("computableSize", false);
        properties.put("access", cacheStats.requestCount());
        properties.put("hit", cacheStats.hitCount());
        properties.put("hitRate", cacheStats.hitRate());
        properties.put("miss", cacheStats.missCount());
        properties.put("missRate", cacheStats.missRate());
        properties.put("nbEviction", cacheStats.evictionCount());
        properties.put("type", CacheType.REQUEST);
        properties.put("currentSize", 0);
        properties.put("maxSize", 0);
        return properties;
    }

    /**
     * Reset all memory caches
     * @return the list of reseted cache's id
     */
    public List<String> resetAllMemoryCaches()
    {
        List<String> cleanedCacheIds = new ArrayList<>();
        for (Cache cache : getAllMemoryCaches())
        {
            cache.resetCache();
            
            cleanedCacheIds.add(cache.getId());
        }
        return cleanedCacheIds;
    }

    /**
     * Reset the cache with provided ids
     * @param ids the list of cache to reset
     * @return the ids of cache that were actually reseted
     */
    public List<String> resetCaches(List<String> ids)
    {
        List<String> cleanedCacheIds = new ArrayList<>();
        for (String id : ids)
        {
            try
            {
                get(id).resetCache();
                cleanedCacheIds.add(id);
            }
            catch (CacheException e)
            {
                getLogger().warn("Failed to clear cache with id '{}'. No cache exists with this id.", id, e);
            }
        }
        return cleanedCacheIds;
    }
    
    /**
     * Reset all request caches that are marked as non dispatchable
     */
    public void resetAllNonDispatchableRequestCaches()
    {
        Request request = null;
        try
        {
            request = ContextHelper.getRequest(_context);
        }
        catch (CascadingRuntimeException e)
        {
            // Nothing... request is null
            getLogger().debug("No request available when resetting non dispatchable request caches", e);
            return;
        }
        
        @SuppressWarnings("unchecked")
        List<String> attrNames = Collections.list(request.getAttributeNames());
        for (String attrName : attrNames)
        {
            if (attrName != null && attrName.startsWith(AbstractCacheManager.ROLE))
            {
                String id = StringUtils.replace(attrName, AbstractCacheManager.ROLE + "$", StringUtils.EMPTY);
                Cache<Object, Object> cache = get(id);
                if (!cache.isDispatchable())
                {
                    refreshStats(request, id);
                    cache.resetCache();
                }
            }
        }
    }
}