/*
 *  Copyright 2019 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.vuejs;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.avalon.framework.parameters.Parameters;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Response;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceException;
import org.apache.excalibur.source.TraversableSource;
import org.apache.excalibur.source.impl.FileSource;

import org.ametys.plugins.core.ui.resources.AbstractCompiledResourceHandler;

/**
 * Resource handler to compile any Vue.js resource on the fly if needed, or serve it
 * The sources have to be located in a directory X/vuejs, while the resources will be sought at X/resources/vuejs 
 */
public class VueJsResourceHandler extends AbstractCompiledResourceHandler
{
    @Override
    protected boolean _isBasicallySupported(String source)
    {
        LocationParser lp = new LocationParser(source);
        return lp.matches();
    }

    @Override
    public int getPriority()
    {
        return MAX_PRIORITY - 500;
    }

    public void generateResource(Source source, OutputStream out, Map objectModel, Parameters parameters, Map<String, Object> additionalParameters) throws IOException, ProcessingException
    {
        if (source.getURI().endsWith(".map"))
        {
            // Sourcemap url needs to be adapted
            try (InputStream is = source.getInputStream())
            {
                String mapContent = IOUtils.toString(is, StandardCharsets.UTF_8);
                String mapContentFixed = StringUtils.replaceAll(mapContent, "\"webpack://[^\"]*(/vueserve/[^\\\"]*\")", "\".$1");
                IOUtils.write(mapContentFixed, out, StandardCharsets.UTF_8);
            }
        }
        else
        {
            // Source where compile during #setup ; in method #getSourceToCompile
            try (InputStream is = source.getInputStream())
            {
                IOUtils.copy(is, out);
            }
        }
    }

    @Override
    public long getLastModified(Source source, Parameters parameters)
    {
        return _getLastModified(source);
    }

    // Recursively get the most recent last modified date
    private long _getLastModified(Source inputSource)
    {
        long result = inputSource.getLastModified();
        
        if (_isSourceDirectory(inputSource))
        {
            TraversableSource folder = (TraversableSource) inputSource;
            try
            {
                Collection<Source> children = folder.getChildren();
                for (Source child : children)
                {
                    result = Math.max(result, _getLastModified(child));
                }
            }
            catch (SourceException e)
            {
                getLogger().warn("Cannot get dependencies files of source " + inputSource.getURI(), e);
            }
            
        }
        
        return result;
    }
    
    
    @Override
    protected List<String> getDependenciesList(Source inputSource)
    {
        List<String> dependencies = new ArrayList<>();

        if (_isSourceDirectory(inputSource))
        {
            TraversableSource folder = (TraversableSource) inputSource;
            try
            {
                Collection<Source> children = folder.getChildren();
                for (Source child : children)
                {
                    dependencies.add(child.getURI());
                }
            }
            catch (SourceException e)
            {
                getLogger().warn("Cannot get dependencies files of source " + inputSource.getURI(), e);
            }
        }
        
        return dependencies;
    }

    private boolean _isSourceDirectory(Source inputSource)
    {
        return inputSource instanceof TraversableSource && ((TraversableSource) inputSource).isCollection() && !inputSource.getURI().endsWith("/node_modules/") && !inputSource.getURI().endsWith("/dist/"); // FIXME should use LocationParser.__OUTPUT_DIR
    }

    @Override
    protected Source getSourceToCompile(String rawLocation, Map<String, Object> additionalParameters) throws MalformedURLException, IOException
    {
        // css files are already minimized files
        String location = rawLocation.replaceAll("\\.min\\.css$", ".css");
        
        // In this implementation, it is not: one source => one target file
        // We cannot know if a given file will exists after compilation without compiling
        // So we pre-compile all the time
        
        
        LocationParser lp = new LocationParser(location);
        if (!lp.matches())
        {
            throw new IOException("Path does not match: " + location);
        }
        
        // Special case for source maps: we serve ".vue" files in the source directory
        Source vueSourceFileSource = _handleSouresFiles(lp);
        if (vueSourceFileSource != null)
        {
            return vueSourceFileSource;
        }

        // Now lets do the job
        Source componentSource = _resolver.resolveURI(lp.getComponentLocation());
        Source binarySource = _resolver.resolveURI(lp.getBinaryLocation());
        
        synchronized (this)
        {
            // Are compiled files not up-to-date?
            if (!binarySource.exists() || binarySource.getLastModified() < _getLastModified(componentSource))
            {
                Source packageJsonSource = _resolver.resolveURI(lp.getPackageJSONLocation());
                if (!binarySource.exists() || binarySource.getLastModified() < _getLastModified(packageJsonSource))
                {
                    // we cannot get last modification time of node_modules (too long)
                    // so lets compare if package.json file is newer than last compilation
                    
                    try
                    {
                        _installDependencies(lp);
                    }
                    catch (ProcessingException e)
                    {
                        throw new IOException("Error while retrieving dependencies: " + location, e);
                    }
                }
                
                try
                {
                    _compile(lp, binarySource);
                }
                catch (ProcessingException e)
                {
                    throw new IOException("Compilation error with module: " + location, e);
                }
            }
        }
        
        Source binaryResource = _resolver.resolveURI(lp.getBinaryLocation() + lp.getVuejsFile());
        return binaryResource;
    }
    
    private Source _handleSouresFiles(LocationParser lp) throws MalformedURLException, IOException
    {
        if (StringUtils.endsWith(lp.getVuejsFile(), ".vue"))
        {
            // Fix a chrome issue with sourcemaps file and cache...
            Response response = ContextHelper.getResponse(_context);
            response.setDateHeader("Expires", 0);
            
            // This is related to sourcemap
            Source originalResource = _resolver.resolveURI(lp.getSourceLocation() + lp.getVuejsFile());
            return originalResource;
        }
        else
        {
            return null;
        }
            
    }

    private void _compile(LocationParser lp, Source binarySource) throws IOException, ProcessingException
    {
        if (getLogger().isInfoEnabled())
        {
            getLogger().info("Compiling " + lp.getSourceLocation());
        }
        
        File sourceDir = ((FileSource) _resolver.resolveURI(lp.getSourceLocation())).getFile();
        File outputDir = ((FileSource) binarySource).getFile();
        outputDir.delete();
        Process process = Runtime.getRuntime().exec(ArrayUtils.addAll(_getCmdExec(), new String[] {"vue", "build", "--target", "lib", "--dest", outputDir.getAbsolutePath()}), null, sourceDir);
        
        List<String> out = new ArrayList<>();
        ReadStream inputStreamReader = new ReadStream(process.getInputStream(), out);
        ReadStream errorStreamReader = new ReadStream(process.getErrorStream(), out);
        Thread inputThread = new Thread(inputStreamReader);
        Thread errorThread = new Thread(errorStreamReader);
        inputThread.start();
        errorThread.start();
        
        try
        {
            int exitCode = process.waitFor();
            
            // We cannot get the process exit code since the CLI will always return 0...
            // We cannot check if errorStreamReader.isEmpty() since it is not
            // So let's search the ERROR keyword
            String outAsString = StringUtils.join(out, '\n');
            
            if (exitCode != 0 || outAsString.contains("ERROR")) 
            {
                throw new ProcessingException("Could not compile " + lp.getSourceLocation() + " due to:\n" + outAsString);
            }
            else if (getLogger().isInfoEnabled())
            {
                getLogger().info("Compilation of " + lp.getSourceLocation() + " ended with:\n" + outAsString);
            }
        }
        catch (InterruptedException e)
        {
            throw new ProcessingException(e);
        }
    }
    
    private void _installDependencies(LocationParser lp) throws IOException, ProcessingException
    {
        if (getLogger().isInfoEnabled())
        {
            getLogger().info("Getting dependencies of " + lp.getSourceLocation());
        }
        
        File sourceDir = ((FileSource) _resolver.resolveURI(lp.getSourceLocation())).getFile();
        Process process = Runtime.getRuntime().exec(ArrayUtils.addAll(_getCmdExec(), new String[] {"npm", "install"}), null, sourceDir);
        
        List<String> out = new ArrayList<>();
        ReadStream inputStreamReader = new ReadStream(process.getInputStream(), out);
        ReadStream errorStreamReader = new ReadStream(process.getErrorStream(), out);
        Thread inputThread = new Thread(inputStreamReader);
        Thread errorThread = new Thread(errorStreamReader);
        inputThread.start();
        errorThread.start();
        
        try
        {
            int exitCode = process.waitFor();
            
            // We cannot get the process exit code since the CLI will always return 0...
            // We cannot check if errorStreamReader.isEmpty() since it is not
            // So let's search the ERROR keyword
            String outAsString = StringUtils.join(out, '\n');
            
            if (exitCode != 0 || outAsString.contains("ERROR")) 
            {
                throw new ProcessingException("Could not get dependencies " + lp.getSourceLocation() + " due to:\n" + outAsString);
            }
            else if (getLogger().isInfoEnabled())
            {
                getLogger().info("Installing dependencies of " + lp.getSourceLocation() + " ended with:\n" + outAsString);
            }
        }
        catch (InterruptedException e)
        {
            throw new ProcessingException(e);
        }

    }
    
    // We cannot execute directly "vue", because java do not take in the path env var
    private String[] _getCmdExec()
    {
        if (System.getProperty("os.name").toLowerCase().startsWith("windows"))
        {
            return new String[] {"cmd", "/c"};
        }
        else
        {
            return new String[] {};
        }
    }
    
    static final class LocationParser
    {
        private static final Pattern __LOCATION = Pattern.compile("^(.*)(/[^/]*)(/vuejs)(/[^/]*)(/.*)$");
        private static final String __OUTPUT_DIR = File.separator + "dist";
        private static final String __SOURCE_DIR = File.separator + "src";
        private static final String __PACKAGE_JSON_FILE = File.separator + "package.json";
        
        private String _location;
        private String _mainLocation;
        private String _parentFolder;
        private String _vuejsDirectoryName;
        private String _vuejsComponentName;
        private String _vuejsFile;

        LocationParser(String location)
        {
            _location = location;
            
            Matcher matcher = __LOCATION.matcher(location);
            if (matcher.matches())
            {
                // cocoon://plugins/test/resources/vuejs/mycomponent/main.js
                _mainLocation = matcher.group(1);       // cocoon://plugins/test
                _parentFolder = matcher.group(2);       // /resources
                _vuejsDirectoryName = matcher.group(3); // /vuesjs
                _vuejsComponentName = matcher.group(4); // /mycomponent
                _vuejsFile = matcher.group(5);          // /main.js
            }
        }
        
        boolean matches()
        {
            return _mainLocation != null;
        }
        
        String getLocation()
        {
            return _location;
        }
        
        String getParentFolder()
        {
            return _parentFolder;
        }
        
        String getComponentLocation()
        {
            return _mainLocation + _vuejsDirectoryName + _vuejsComponentName;
        }
        
        String getPackageJSONLocation()
        {
            return getComponentLocation() + __PACKAGE_JSON_FILE;
        }
        
        String getVuejsFile()
        {
            return _vuejsFile;
        }
        
        String getBinaryLocation()
        {
            return _mainLocation + _vuejsDirectoryName + _vuejsComponentName + __OUTPUT_DIR;
        }
        
        String getSourceLocation()
        {
            return _mainLocation + _vuejsDirectoryName + _vuejsComponentName + __SOURCE_DIR;
        }
    }
    
    class ReadStream implements Runnable 
    {
        private final InputStream _inputStream;
        private final List<String> _sf;
        private boolean _isEmpty;

        ReadStream(InputStream inputStream, List<String> sf) 
        {
            _inputStream = inputStream;
            _sf = sf;
            _isEmpty = true;
        }

        private BufferedReader getBufferedReader(InputStream is) 
        {
            return new BufferedReader(new InputStreamReader(is));
        }

        @Override
        public void run() 
        {
            BufferedReader br = getBufferedReader(_inputStream);
            String line = "";
            try 
            {
                while ((line = br.readLine()) != null) 
                {
                    _sf.add(line);
                    _isEmpty = false;
                }
            } 
            catch (IOException e) 
            {
                e.printStackTrace();
            }
        }
        
        boolean isEmpty()
        {
            return _isEmpty;
        }
    }
}