/*
 *  Copyright 2017 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.plugins.core.ui.minimize;

import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.lang3.StringUtils;

import org.ametys.core.cache.AbstractCacheManager;
import org.ametys.core.cache.Cache;
import org.ametys.plugins.core.ui.resources.ResourceDependenciesListExtensionPoint;
import org.ametys.plugins.core.ui.util.RequestAttributesHelper;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * The cache for hashed list of files to minimize
 */
public class HashCache extends AbstractLogEnabled implements Component, Serviceable, Initializable
{
    /** The avalon ROLE */
    public static final String ROLE = HashCache.class.getName();
    
    /** RequestAttributesHelper */
    protected RequestAttributesHelper _requestAttributesHelper;

    /** ResourceDependenciesListExtensionPoint */
    protected ResourceDependenciesListExtensionPoint _resourceDependenciesListEP;

    /** CacheManager used to create and get cache */
    protected AbstractCacheManager _cacheManager;

    public void service(ServiceManager manager) throws ServiceException
    {
        _requestAttributesHelper = (RequestAttributesHelper) manager.lookup(RequestAttributesHelper.ROLE);
        
        _resourceDependenciesListEP = (ResourceDependenciesListExtensionPoint) manager.lookup(ResourceDependenciesListExtensionPoint.ROLE);
        
        _cacheManager = (AbstractCacheManager) manager.lookup(AbstractCacheManager.ROLE);
    }

    public void initialize() throws Exception
    {
        _cacheManager.createMemoryCache(ROLE, 
                new I18nizableText("plugin.core", "PLUGINS_CORE_CACHE_HASH_LABEL"),
                new I18nizableText("plugin.core", "PLUGINS_CORE_CACHE_HASH_DESCRIPTION"),
                true,
                null);
    }
    
    /**
     * Get the file list corresponding to the given hashcode
     * @param hash The hashcode created by createHash in this session
     * @param firstLevel File imported by other files will not be included
     * @return The list of files or null if the hashcode does not exists
     */
    public List<UriData> getFilesForHash(String hash, boolean firstLevel)
    {
        List<UriData> uriDataList = _getCache().get(hash);
        if (firstLevel)
        {
            return uriDataList.stream()
                    .filter(UriData::isFirstLevel)
                    .collect(Collectors.toList());
        }
        return uriDataList;
    }
    
    /**
     * Creates and memorize a hash code corresponding to a list of files 
     * @param files The files. Key is the file uri and the value is a map with two keys 'media' and 'tag'.
     * @param salt Additional parameter used as salt for the hash key.
     * @return The hash code
     * @throws IllegalArgumentException If an error occurred
     */
    public String createHash(Map<String, Map<String, String>> files, String salt) throws IllegalArgumentException
    {
        List<UriData> hashCache = new ArrayList<>();
        
        Map<String, Object> attributes = _requestAttributesHelper.saveRequestAttributes();
        
        try
        {
            files.entrySet().stream()
                    .map(file -> _resourceDependenciesListEP.getDependencies(file.getKey(), file.getValue()))
                    .filter(Objects::nonNull)
                    .forEach(fileDependencies -> hashCache.addAll(fileDependencies));
            
            String hash = Base64.getEncoder().withoutPadding().encodeToString(String.valueOf(31 * hashCache.hashCode() + salt.hashCode()).getBytes("UTF-8"));
            _getCache().put(hash, hashCache);
            return hash;
        }
        catch (UnsupportedEncodingException e)
        {
            throw new IllegalArgumentException(e);
        }
        finally
        {
            _requestAttributesHelper.restoreRequestAttributes(attributes);
        }
    }

    /**
     * The description of an URI
     */
    public static class UriData
    {
        private String _uri;
        private Long _lastModified;
        private String _media;
        private boolean _firstLevel;
        
        /**
         * Default constructor for a file data
         * @param uri The uri locating the file
         * @param firstLevel False if the file data is an import from another file data
         */
        public UriData(String uri, boolean firstLevel)
        {
            _uri = uri;
            _firstLevel = firstLevel;
        }
        
        /**
         * Set the last modified value
         * @param lastModified the lastModified to set
         */
        public void setLastModified(Long lastModified)
        {
            this._lastModified = lastModified;
        }

        /**
         * set the medias value
         * @param media the medias to set
         */
        public void setMedia(String media)
        {
            this._media = media;
        }

        /**
         * Get the file uri
         * @return the uri
         */
        public String getUri()
        {
            return _uri;
        }
        
        /**
         * Get the file last modified date
         * @return the lastModified
         */
        public Long getLastModified()
        {
            return _lastModified;
        }
        
        /**
         * Get the file medias
         * @return the medias
         */
        public String getMedia()
        {
            return _media;
        }
        
        /**
         * Check if the file is a first level file
         * @return True if the file is first level
         */
        public boolean isFirstLevel()
        {
            return _firstLevel;
        }
        
        @Override
        public boolean equals(Object obj)
        {
            if (obj instanceof UriData)
            {
                UriData fObj = (UriData) obj;
                return StringUtils.equals(_uri, fObj._uri)
                        && (_lastModified == null ? fObj._lastModified == null : _lastModified.equals(fObj._lastModified)) 
                        && StringUtils.equals(_media, fObj._media);
            }
            return false;
        }
        
        @Override
        public int hashCode()
        {
            return Objects.hash(_uri, _lastModified, _media);
        }
        
        @Override
        public String toString()
        {
            if (_media != null)
            {
                return _uri + "#" + _media + " (" + _lastModified + ")";
            }
            else
            {
                return _uri + " (" + _lastModified + ")";
            }
        }
    }

    private Cache<String, List<UriData>> _getCache() 
    {
        return this._cacheManager.get(ROLE);
    }
}