/*
 *  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.minimize;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

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.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;

import org.ametys.core.resources.ProxiedContextPathProvider;
import org.ametys.plugins.core.ui.minimize.HashCache.UriData;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

import com.google.debugging.sourcemap.SourceMapFormat;
import com.google.debugging.sourcemap.SourceMapGeneratorFactory;
import com.google.debugging.sourcemap.SourceMapGeneratorV3;

/**
 * Abstract minimize manager for js and css
 */
public abstract class AbstractMinimizeManager extends AbstractLogEnabled implements Serviceable
{
    // regex that matches the "sources" property of a sourcemap
    private static final Pattern __SOURCEMAP_SOURCE_NAME = Pattern.compile("\\s*\"sources\"\\s*:" // Matches the literal '"file" :' with any whitespace
                                                                         + "\\s*"
                                                                         + "\\[\\s*" // Matches the bracket that starts the list of sources
                                                                         + "([^\\]]+)" // Captures the sources
                                                                         + "\\]", // Matches the closing bracket at the end of sources 
                                                                         Pattern.MULTILINE | Pattern.DOTALL);
    
    // Captures a string in between double quotes
    private static final Pattern SOURCE_MAP_SOURCE = Pattern.compile("\"([^\"]+)\"");
    
    /** The source map cache component */
    protected SourceMapCache _sourceMapCache;

    /** The proxied context path provider */
    protected ProxiedContextPathProvider _proxiedContextPathProvider;

    /** Ametys source resolver */
    protected SourceResolver _resolver;

    @Override
    public void service(ServiceManager smanager) throws ServiceException
    {
        _sourceMapCache = (SourceMapCache) smanager.lookup(SourceMapCache.ROLE);
        _proxiedContextPathProvider = (ProxiedContextPathProvider) smanager.lookup(ProxiedContextPathProvider.ROLE);
        _resolver = (SourceResolver) smanager.lookup(SourceResolver.ROLE);
    }
    
    /**
     * Compile a list of css URI, store the generated source map and returns the minimized concatenated result
     * @param uris The URIs to compile, e.g a list of mixed .min.css and .css URIs
     * @param fileName The name of the result without extension, e.g. HASH
     * @param generateSourceMap True to generate the source map
     * @return The minimized file
     */
    public String minimizeAndAggregateURIs(List<UriData> uris, String fileName, boolean generateSourceMap)
    {
        SourceMapGeneratorV3 sourceMapGenerator = generateSourceMap ? (SourceMapGeneratorV3) SourceMapGeneratorFactory.getInstance(SourceMapFormat.V3) : null;
        int totalLineCount = 0;
        
        StringBuffer sb = new StringBuffer();
        for (UriData uri : uris)
        {
            String content = getMinimizedContent(uri.getUri(), "");
            if (!content.endsWith("\n") && !content.endsWith("\n\r"))
            {
                content += "\n";
            }

            String[] lines = content.split("\r\n|\r|\n", -1);
            int lineCount = lines.length;
            
            while (lineCount > 0 && StringUtils.isEmpty(lines[lineCount - 1]))
            {
                lineCount--;
            }
            
            boolean hasMedia = StringUtils.isNotEmpty(uri.getMedia());
            if (hasMedia)
            {
                totalLineCount += 1; // offset source map by one to let the line for the media
            }
            
            // files with a sourceMappingURL should end with an empty line after
            String lastLine = lineCount > 0 ? lines[lineCount - 1] : null;
            if (isSourceMappingURLLine(lastLine)) 
            {
                String mapURL = getSourceMappingURL(lastLine);
                content = removeSourceMappingURLLine(content);
                if (generateSourceMap)
                {
                    addSourceMap(sourceMapGenerator, totalLineCount, content, uri.getUri(), mapURL);
                }
                lineCount--; // last line of current file and first line of next file are on the same merged line
            }
            else if (lastLine != null && lines.length > lineCount)
            {
                // Trim empty lines at the end of the file
                content = content.substring(0, content.lastIndexOf(lastLine) + lastLine.length()).trim() + "\n";
            }
            
            totalLineCount += lineCount;
            sb.append(hasMedia ? applyMediaToContent(content, uri.getMedia()) : content);
        }
        
        _generateSourceMap(sourceMapGenerator, sb, fileName, fileName + ".map", generateSourceMap);
        
        return sb.toString();
    }
    
    /**
     * Defaut implementation to apply a media to a content.
     * @param content The content
     * @param media The media
     * @return The content with the media
     */
    protected String applyMediaToContent(String content, String media)
    {
        return "\n" + content; // do nothing, but add an empty line for consistency
    }

    private void _generateSourceMap(SourceMapGeneratorV3 sourceMapGenerator, StringBuffer sb, String fileName, String sourceMapName, boolean generateSourceMap)
    {
        try
        {
            if (generateSourceMap)
            {
                StringBuilder sbMap = new StringBuilder();
                sourceMapGenerator.appendTo(sbMap, fileName);
                _sourceMapCache.put(sourceMapName, sbMap.toString(), (long) 0);
            }

            sb.append("\n" + formatSourceMappingURL(sourceMapName));
        }
        catch (IOException e)
        {
            getLogger().error("Unable to create final source map for minimized file", e);
        }
    }
    
    /**
     * Convert the source map "sources" attribute by correcting the path of those values
     * @param content The source map content
     * @param uri The URI (without context path)
     * @return The converted source map
     * @throws URISyntaxException If an error occurred
     */
    protected String convertSourceMapURIs(String content, String uri) throws URISyntaxException
    {
        String sourceMapContent = content;
        
        Matcher matcher = __SOURCEMAP_SOURCE_NAME.matcher(sourceMapContent);
        if (matcher.find())
        {
            String originalSources = matcher.group(1);
            
            // Parse each source and transform to absolute path if necessary
            StringBuffer sb = new StringBuffer();
            Matcher sourcesMatcher = SOURCE_MAP_SOURCE.matcher(originalSources);
            while (sourcesMatcher.find())
            {
                String source = sourcesMatcher.group(1);
                if (source.indexOf("/") != 0)
                {
                    String realSourceUri = _proxiedContextPathProvider.getContextPath() + new URI(StringUtils.substringBeforeLast(uri, "/") + "/" + source).normalize().toString();
                    sourcesMatcher.appendReplacement(sb, Matcher.quoteReplacement(sourcesMatcher.group(0).replace(source, realSourceUri)));
                }
            }
            sourcesMatcher.appendTail(sb);
            
            sourceMapContent = sourceMapContent.replace(originalSources, sb.toString());
        }
        return sourceMapContent;
    }
    
    /**
     * Validate a source, fix it if required, and output the result to the output stream.
     * @param source The source
     * @param out The output
     * @param sourceUri The source uri
     * @throws IOException If an error occurred while reading the source
     */
    public void validateAndOutputMinimizedFile(Source source, OutputStream out, String sourceUri) throws IOException
    {
        String fileContent;
        try (InputStream is = source.getInputStream())
        {
            fileContent = IOUtils.toString(is, StandardCharsets.UTF_8);
        }
        
        String[] lines = fileContent.split("\r\n|\r|\n", -1);
        int lineCount = lines.length;
        
        while (lineCount > 0 && StringUtils.isEmpty(lines[lineCount - 1]))
        {
            lineCount--;
        }
        
        // files with a sourceMappingURL should end with an empty line after
        String lastLine = lineCount > 0 ? lines[lineCount - 1] : null;
        
        if (isSourceMappingURLLine(lastLine))
        {
            String mapURL = getSourceMappingURL(lastLine);
            String uriToResolve = sourceUri.indexOf('/') > -1 ? sourceUri.substring(0, sourceUri.lastIndexOf("/") + 1) + mapURL : mapURL;
            
            Source mapSource = null;
            try
            {
                mapSource = _resolver.resolveURI(uriToResolve);
            }
            catch (IOException e)
            {
                // Nothing
            }
            
            if (mapSource == null || !mapSource.exists())
            {
                fileContent = removeSourceMappingURLLine(fileContent);
            }
        }

        out.write(fileContent.getBytes(StandardCharsets.UTF_8));
    }

    /**
     * Test if the line contains a source mapping URL
     * @param line The line
     * @return True if a source mapping url is found
     */
    protected abstract boolean isSourceMappingURLLine(String line);
    
    /**
     * Get the source mapping URL value from the line
     * @param line The line
     * @return The source mapping URL
     */
    protected abstract String getSourceMappingURL(String line);
    
    /**
     * Remove the source mapping url from the content
     * @param content The content
     * @return The content without the mention of the source mapping URL
     */
    protected abstract String removeSourceMappingURLLine(String content);
    
    /**
     * Format a source mapping URL to be added at the end of a minimized file
     * @param sourceMapName The map name 
     * @return The source mapping URL line
     */
    protected abstract String formatSourceMappingURL(String sourceMapName);
    
    /**
     * Get the minimized content at the specified URI
     * @param uri The uri 
     * @param nestedParentFilesName The parents file name, can be an empty string if there are no parents
     * @return The minimized content of the specified URI
     */
    protected abstract String getMinimizedContent(String uri, String nestedParentFilesName);
    
    /**
     * Aggregate the source map of the single file with the others 
     * @param sourceMapGenerator The aggregator helper
     * @param lineCount The current line count
     * @param fileContent The content of the file
     * @param fileUri The uri of the file
     * @param sourceMapUri The sourceMappingURL found at the end of the file content
     */
    protected abstract void addSourceMap(SourceMapGeneratorV3 sourceMapGenerator, int lineCount, String fileContent, String fileUri, String sourceMapUri);
    
}