/*
 *  Copyright 2016 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.resources;

import java.io.Serializable;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.avalon.framework.component.Component;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceValidity;
import org.apache.excalibur.source.impl.validity.TimeStampValidity;

import org.ametys.core.resources.DefaultResourceHandler;

/**
 * Abstract reader for resources compiled during runtime, such as SASS or LESS files compiled into CSS.
 */
public abstract class AbstractCompiledResourceHandler extends DefaultResourceHandler implements Component
{
    /* Dependencies cache */
    private static Map<String, Pair<List<String>, Long>> _dependenciesCache = new ConcurrentHashMap<>();
    
    /**
     * Constructor with an already resolved {@link Source}.
     * @param source the source
     */
    public AbstractCompiledResourceHandler(Source source)
    {
        super(source);
    }
    
    /**
     * Calculate the list of dependencies for the given source, for validity calculations.
     * @param inputSource The source
     * @return The list of uri
     */
    protected abstract List<String> getDependenciesList(Source inputSource);
    
    @Override
    public Serializable getKey()
    {
        return _getDependenciesKeys(_source, _source.getURI(), FilenameUtils.normalize(_source.getURI()), _source.getLastModified(), new HashMap<String, String>());
    }

    @Override
    public SourceValidity getValidity()
    {
        Long lastModified = _getCalculatedLastModified(_source, _source.getURI(), _source.getLastModified(), new HashMap<String, String>());
        return lastModified != null ? new TimeStampValidity(lastModified) : null;
    }

    private Long _getCalculatedLastModified(Source inputSource, String sourceUri, long lastModified, HashMap<String, String> knowDependencies)
    {
        long result = lastModified;
        List<String> dependencies = _getDependencies(inputSource, sourceUri, lastModified);
        
        for (String dependency : dependencies)
        {
            if (dependency != null && !StringUtils.startsWith(dependency, "http://") && !StringUtils.startsWith(dependency, "https://"))
            {
                try
                {
                    String uriToResolve = _getDependencyURI(sourceUri, dependency);
                    
                    HashMap<String, Object> params = new HashMap<>();
                    Source dependencySource = _resolver.resolveURI(uriToResolve, null, params);
                    String fsURI = FilenameUtils.normalize(dependencySource.getURI());
                    if (!knowDependencies.containsKey(fsURI))
                    {
                        knowDependencies.put(fsURI, sourceUri);

                        Long calculatedLastModified = _getCalculatedLastModified(dependencySource, uriToResolve, dependencySource.getLastModified(), knowDependencies);
                        if (calculatedLastModified != null && calculatedLastModified > result)
                        {
                            result = calculatedLastModified;
                        }
                    }
                }
                catch (Exception e)
                {
                    getLogger().warn("Unable to resolve the following uri : '" + dependency + "' while calculating dependencies for " + inputSource.getURI(), e);
                    return null;
                }
            }
        }
        
        return result;
    }
    
    private String _getDependenciesKeys(Source inputSource, String sourceUri, String fileURI, long lastModified, HashMap<String, String> knowDependencies)
    {
        String result = fileURI;
        List<String> dependencies = _getDependencies(inputSource, sourceUri, lastModified);
        
        for (String dependency : dependencies)
        {
            if (dependency != null && !StringUtils.startsWith(dependency, "http://") && !StringUtils.startsWith(dependency, "https://"))
            {
                try
                {
                    String uriToResolve = _getDependencyURI(sourceUri, dependency);
                    
                    HashMap<String, Object> params = new HashMap<>();
                    Source dependencySource = _resolver.resolveURI(uriToResolve, null, params);
                    String fileDependencyURI = FilenameUtils.normalize(dependencySource.getURI());
                    if (knowDependencies.containsKey(fileDependencyURI))
                    {
                        getLogger().warn("A loop import was detected in file : '" + sourceUri + "' that imports '" + fileDependencyURI 
                                + "' but it was already previously imported by '" + knowDependencies.get(fileDependencyURI) + "'.");
                    }
                    else
                    {
                        knowDependencies.put(fileDependencyURI, sourceUri);
                        String dependenciesKeys = _getDependenciesKeys(dependencySource, uriToResolve, fileDependencyURI, dependencySource.getLastModified(), knowDependencies);
                        if (dependenciesKeys != null)
                        {
                            result = result + "*" + dependenciesKeys;
                        }
                    }
                }
                catch (Exception e)
                {
                    getLogger().warn("Unable to resolve the following uri : '" + dependency + "' while calculating dependencies for " + inputSource.getURI(), e);
                    return null;
                }
            }
        }
        
        return result;
    }
    
    private String _getDependencyURI(String sourceUri, String dependency) throws URISyntaxException
    {
        URI uri = new URI(dependency);
        String uriToResolve = uri.isAbsolute() ? dependency : FilenameUtils.getFullPath(sourceUri) + dependency;
        
        // Don't normalize the schema part of the uri
        String schema = StringUtils.contains(uriToResolve, "://") ? uriToResolve.substring(0, uriToResolve.indexOf("://") + 3) : "";
        uriToResolve = schema + FilenameUtils.normalize(StringUtils.removeStart(uriToResolve, schema));
        return uriToResolve;
    }

    private List<String> _getDependencies(Source inputSource, String sourceUri, long lastModified)
    {
        Pair<List<String>, Long> cachedDependencies = _dependenciesCache.get(sourceUri);
        
        List<String> dependencies;
        
        if (cachedDependencies == null || !cachedDependencies.getRight().equals(lastModified))
        {
            // Cache is out of date
            dependencies = getDependenciesList(inputSource);
            _dependenciesCache.put(sourceUri, Pair.of(dependencies, lastModified));
        }
        else
        {
            dependencies = cachedDependencies.getLeft();
        }
        
        return dependencies;
    }
}