/*
 *  Copyright 2018 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.util.filereloader;

import java.io.InputStream;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

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.excalibur.source.Source;
import org.apache.excalibur.source.SourceNotFoundException;
import org.apache.excalibur.source.SourceResolver;

import org.ametys.core.cache.AbstractCacheManager;
import org.ametys.core.cache.Cache;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * a helper to track modification of a configuration file
 */
public class FileReloaderUtils extends AbstractLogEnabled implements Component, Serviceable, Initializable
{
    /** The avalon role */
    public static final String ROLE = FileReloaderUtils.class.getName();
    
    private static final String __FILERELOADER_CACHE = FileReloaderUtils.class.getName() + "$Cache";
    
    /** The source resolver */
    protected SourceResolver _resolver;
    
    private AbstractCacheManager _cacheManager;
    private Map<String, FileMetadatas> _files;

    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _resolver = (SourceResolver) manager.lookup(SourceResolver.ROLE);
        _cacheManager = (AbstractCacheManager) manager.lookup(AbstractCacheManager.ROLE);
    }
    
    public void initialize() throws Exception
    {
        _files = new ConcurrentHashMap<>();
        
        _cacheManager.createRequestCache(__FILERELOADER_CACHE, 
                new I18nizableText("plugin.core", "PLUGINS_CORE_FILERELOADER_CACHE_LABEL"),
                new I18nizableText("plugin.core", "PLUGINS_CORE_FILERELOADER_CACHE_DESCRIPTION"),
                true);
    }
    
    /**
     * Request to read/update the file
     * @param sourceUrl url of the file to read
     * @param fileReloader FileReloader that will be called to get an ID and read the file
     * @throws Exception the source can not be read
     */
    public void updateFile(String sourceUrl, FileReloader fileReloader) throws Exception
    {
        updateFile(sourceUrl,  null, fileReloader);
    }
    
    /**
     * Request to read/update the file
     * @param sourceUrl url of the file to read
     * @param forceRead true to force reload even if the file was not modified
     * @param fileReloader FileReloader that will be called to get an ID and read the file
     * @throws Exception the source can not be read
     */
    public void updateFile(String sourceUrl, boolean forceRead, FileReloader fileReloader) throws Exception
    {
        updateFile(sourceUrl, null, forceRead, fileReloader);
    }
    
    /**
     * Request to read/update the file
     * @param sourceUrl url of the file to read
     * @param parameters parameters passed to the resolver to get the file via it's url (can be null)
     * @param fileReloader FileReloader that will be called to get an ID and read the file
     * @throws Exception the source can not be read
     */
    public void updateFile(String sourceUrl, Map parameters, FileReloader fileReloader) throws Exception
    {
        updateFile(sourceUrl, parameters, false, fileReloader);
    }

    /**
     * Request to read/update the file
     * @param sourceUrl url of the file to read
     * @param parameters parameters passed to the resolver to get the file via it's url (can be null)
     * @param forceRead true to force reload even if the file was not modified
     * @param fileReloader FileReloader that will be called to get an ID and read the file
     * @throws Exception the source can not be read
     */
    public void updateFile(String sourceUrl, Map parameters, boolean forceRead, FileReloader fileReloader) throws Exception
    {
        String id = fileReloader.getId(sourceUrl);
        
        Cache<String, Object> cache = _cacheManager.get(__FILERELOADER_CACHE);
        if (!forceRead && cache.get(id) != null) // cache#get used here instead of cache#hasKey to trigger hit/miss stats
        {
            // already been handled in this request 
            return;
        }
        
        FileMetadatas fileMetadatas = _files.computeIfAbsent(id, i -> new FileMetadatas(sourceUrl, parameters));
        synchronized (fileMetadatas)
        {
            Source source = null;
            try
            {
                source = _resolver.resolveURI(fileMetadatas.getSourceUrl(), null, fileMetadatas.getParameters());
                if (!source.exists())
                {
                    throw new SourceNotFoundException("Source '" + fileMetadatas.getSourceUrl() + "' not found");
                }
                
                long sourceLastModified = (source.getLastModified() / 1000) * 1000; // hack for file systems only returning seconds
                if (forceRead || sourceLastModified != fileMetadatas.getLastModified())
                {
                    getLogger().debug("Reading configuration file at {}", fileMetadatas.getSourceUrl());
                    
                    try (InputStream is = source.getInputStream())
                    {
                        fileReloader.updateFile(fileMetadatas.getSourceUrl(), source, is);
                        fileMetadatas.setLastModified(sourceLastModified);
                        getLogger().debug("Configuration file read. at {}", fileMetadatas.getSourceUrl());
                    }
                }
            }
            catch (SourceNotFoundException e)
            {
                if (forceRead || fileMetadatas.getLastModified() != FileMetadatas.FILE_DOES_NOT_EXIST)
                {
                    getLogger().debug("File at {} could not be found", fileMetadatas.getSourceUrl(), e);
                    fileReloader.updateFile(fileMetadatas.getSourceUrl(), null, null);
                }
                
                fileMetadatas.setLastModified(FileMetadatas.FILE_DOES_NOT_EXIST);
            }
            finally 
            {
                _resolver.release(source);
                cache.put(id, id); // no matter the value, we only test the presence of the key
            }
        }
    }
    
    private static class FileMetadatas
    {
        /** When the date was not set yet */
        public static final long UNKNOWN = -1;
        /** When there is no corresponding file */
        public static final long FILE_DOES_NOT_EXIST = 0;
        
        private long _lastModified;
        private String _sourceUrl;
        private Map _parameters;

        public FileMetadatas(String sourceUrl, Map parameters)
        {
            this._sourceUrl = sourceUrl;
            this._lastModified = UNKNOWN;
            this._parameters = parameters;
        }
        
        public long getLastModified()
        {
            return this._lastModified;
        }
        public void setLastModified(long lastFileReading)
        {
            this._lastModified = lastFileReading;
        }
        
        public String getSourceUrl()
        {
            return this._sourceUrl;
        }
        
        public Map getParameters()
        {
            return this._parameters;
        }
    }

}