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

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

import org.apache.avalon.framework.parameters.Parameters;
import org.apache.cocoon.ProcessingException;
import org.apache.commons.io.FilenameUtils;
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.plugins.core.ui.resources.AbstractCompiledResourceHandler;
import org.ametys.plugins.core.ui.resources.css.CSSFileHelper;

import com.github.sommeri.less4j.Less4jException;
import com.github.sommeri.less4j.LessCompiler.CompilationResult;
import com.github.sommeri.less4j.LessSource;
import com.github.sommeri.less4j.core.DefaultLessCompiler;

/**
 * Reader for LESS files, compile them on the fly into CSS files.
 */
public class LessResourceHandler extends AbstractCompiledResourceHandler
{
    private DefaultLessCompiler _defaultLessCompiler;
    
    /**
     * Constructor with an already resolved {@link Source}.
     * @param source the source
     */
    public LessResourceHandler(Source source)
    {
        super(source);
    }
    
    @Override
    public Source setup(String location, Map objectModel, Parameters par, boolean readForDownload) throws ProcessingException, IOException
    {
        Source source = super.setup(location, objectModel, par, readForDownload);
        
        _defaultLessCompiler = new DefaultLessCompiler();
        
        return source;
    }
        
    @Override
    public void generate(OutputStream out) throws IOException, ProcessingException
    {
        CompilationResult result = null;
        
        try (InputStream is = _source.getInputStream())
        {
            String lessContent = IOUtils.toString(is, StandardCharsets.UTF_8);
            AmetysLessSource stringSource = new AmetysLessSource(_resolver, lessContent, new URI(_source.getURI()));
            result = _defaultLessCompiler.compile(stringSource);
        }
        catch (Less4jException e)
        {
            throw new ProcessingException("Unable to compile the LESS file : " + _source.getURI(), e);
        }
        catch (URISyntaxException e)
        {
            throw new ProcessingException("Unable to process LESS File, invalid uri : " + _source.getURI(), e);
        }
        
        String resultString = result == null ? null : result.getCss();
        IOUtils.write(resultString, out, StandardCharsets.UTF_8);
    }
    
    @Override
    protected List<String> getDependenciesList(Source inputSource)
    {
        List<String> result = new ArrayList<>();
        
        try (InputStream is = inputSource.getInputStream())
        {
            String content = IOUtils.toString(is, StandardCharsets.UTF_8);
            
            Matcher matcher = CSSFileHelper.IMPORT_PATTERN.matcher(content);
            
            while (matcher.find())
            {
                String cssUrl = matcher.group(1);
                
                if (!StringUtils.contains(cssUrl, "http://") && !StringUtils.contains(cssUrl, "https://")) 
                {
                    if (!StringUtils.endsWith(cssUrl, ".css") && !StringUtils.endsWith(cssUrl, ".less"))
                    {
                        cssUrl += ".less";
                    }
                    
                    result.add(cssUrl);
                }
            }
        }
        catch (IOException e)
        {
            getLogger().warn("Invalid content when listing dependencies for file " + inputSource.getURI(), e);
        }
        
        return result;
    }

    @Override
    public String getMimeType()
    {
        return "text/css";
    }
    
    /**
     * LessSource definition for Ametys Resources
     */
    private static class AmetysLessSource extends LessSource
    {
        private String _lessContent;
        private String _name;
        private URI _sourceUri;
        private SourceResolver _sResolver;
    
        /**
         * Default constructor for Ametys less source
         * @param sourceResolver The Source Resolver
         * @param lessContent The content of the less source
         * @param uri The uri of the less source
         */
        public AmetysLessSource(SourceResolver sourceResolver, String lessContent, URI uri)
        {
            _sResolver = sourceResolver;
            _lessContent = lessContent;
            _sourceUri = uri;
        }
    
        @Override
        public LessSource relativeSource(String relativePath) throws FileNotFound, CannotReadFile, StringSourceException
        {
            Source importSource = null;
            try
            {
                URI relativeSourceUri = new URI(relativePath);
                if (!relativeSourceUri.isAbsolute())
                {
                    relativeSourceUri = new URI(FilenameUtils.getFullPath(_sourceUri.toString()) + relativePath);
                }
                
                importSource = _sResolver.resolveURI(relativeSourceUri.toString());
    
                String importText = IOUtils.toString(importSource.getInputStream(), "UTF-8");
                return new AmetysLessSource(_sResolver, importText, relativeSourceUri);
            }
            catch (Exception e)
            {
                throw new RuntimeException("Unable to process LESS File : " + _sourceUri + ", invalid import : " + relativePath, e);
            }
            finally
            {
                _sResolver.release(importSource);
            }
        }
    
        @Override
        public String getContent() throws FileNotFound, CannotReadFile
        {
            return _lessContent;
        }
    
        @Override
        public byte[] getBytes() throws FileNotFound, CannotReadFile
        {
            try
            {
                return _lessContent.getBytes("UTF-8");
            }
            catch (UnsupportedEncodingException e)
            {
                throw new CannotReadFile();
            }
        }
        
        @Override
        public URI getURI()
        {
            return _sourceUri;
        }
        
        @Override
        public String getName()
        {
            return _name;
        }
    }
}