/*
 *  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.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.HashMap;
import java.util.Map;

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.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();
    
    /** The source resolver */
    protected SourceResolver _resolver;
    
    private Map<String, FileMetadatas> _files;

    public void initialize() throws Exception
    {
        this._files = new HashMap<>();
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _resolver = (SourceResolver) manager.lookup(SourceResolver.ROLE);
    }
    
    /**
     * 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);
        if (!_files.containsKey(id))
        {
            _files.put(id, new FileMetadatas(sourceUrl, parameters));
        }
        
        FileMetadatas fileMetadatas = _files.get(id);
        
        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.getLastFileReading())
                {
                    getLogger().debug("Reading configuration file at {}", fileMetadatas.getSourceUrl());
                    
                    long lastFileReading = Instant.now().truncatedTo(ChronoUnit.SECONDS).toEpochMilli();
                    
                    try (InputStream is = source.getInputStream())
                    {
                        fileReloader.updateFile(fileMetadatas.getSourceUrl(), is);
                        fileMetadatas.setLastFileReading(lastFileReading);
                        getLogger().debug("Configuration file read. at {}", fileMetadatas.getSourceUrl());
                    }
                    
                }
                
            }
            catch (SourceNotFoundException e)
            {
                getLogger().debug("File at {} could not be found", fileMetadatas.getSourceUrl(), e);
                if (forceRead || fileMetadatas.getLastFileReading() < 0)
                {
                    fileReloader.updateFile(fileMetadatas.getSourceUrl(), null);
                }
                fileMetadatas.setLastFileReading(0); // It was initialized with -1 so the update will be forced only once
            }
            finally 
            {
                _resolver.release(source);
            }
        }
    }
    
    private static class FileMetadatas
    {
        private long _lastFileReading;
        private String _sourceUrl;
        private Map _parameters;

        public FileMetadatas(String sourceUrl, Map parameters)
        {
            this._sourceUrl = sourceUrl;
            this._lastFileReading = -1;
            this._parameters = parameters;
        }
        
        public long getLastFileReading()
        {
            return this._lastFileReading;
        }
        public void setLastFileReading(long lastFileReading)
        {
            this._lastFileReading = lastFileReading;
        }
        
        public String getSourceUrl()
        {
            return this._sourceUrl;
        }
        
        public Map getParameters()
        {
            return this._parameters;
        }
    }

}