/*
 *  Copyright 2010 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.web.generation;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.concurrent.locks.Lock;

import javax.jcr.NoSuchWorkspaceException;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.apache.avalon.framework.component.WrapperComponentManager;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.Processor;
import org.apache.cocoon.components.CocoonComponentManager;
import org.apache.cocoon.environment.Context;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.util.log.SLF4JLoggerAdapter;
import org.apache.commons.collections.Predicate;
import org.apache.commons.collections.PredicateUtils;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;
import org.apache.jackrabbit.api.JackrabbitWorkspace;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.ametys.cms.repository.Content;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.metadata.BinaryMetadata;
import org.ametys.plugins.repository.metadata.CompositeMetadata;
import org.ametys.plugins.repository.metadata.Folder;
import org.ametys.plugins.repository.metadata.Resource;
import org.ametys.plugins.repository.metadata.RichText;
import org.ametys.plugins.repository.metadata.jcr.JCRResource;
import org.ametys.plugins.repository.provider.RequestAttributeWorkspaceSelector;
import org.ametys.runtime.config.Config;
import org.ametys.web.WebConstants;
import org.ametys.web.live.LiveAccessManager;
import org.ametys.web.renderingcontext.RenderingContext;
import org.ametys.web.renderingcontext.RenderingContextHandler;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.Zone;
import org.ametys.web.repository.page.ZoneItem;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.sitemap.Sitemap;
import org.ametys.web.synchronization.SynchronizeComponent;

/**
 * Component for generating a site.
 */
public class SiteGenerator implements Serviceable
{
    /** Logger available to subclasses. */
    protected final Logger _logger = LoggerFactory.getLogger(getClass());
    
    private RenderingContextHandler _renderingContextHandler;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _renderingContextHandler = (RenderingContextHandler) manager.lookup(RenderingContextHandler.ROLE);
    }
    
    /**
     * Generates site's content.
     * @param manager the service manager.
     * @param objectModel the objectModel. 
     * @param site the site to populate.
     * @param tempOutputDir the output directory.
     * @throws Exception if an error occurs.
     */
    public void generate(ServiceManager manager, Map objectModel, Site site, File tempOutputDir) throws Exception
    {
        try
        {
            Repository repository = (Repository) manager.lookup(Repository.class.getName());
            AmetysObjectResolver resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
            LiveAccessManager liveAccessManager = (LiveAccessManager) manager.lookup(LiveAccessManager.ROLE);
            SynchronizeComponent synchronizeComponent = (SynchronizeComponent) manager.lookup(SynchronizeComponent.ROLE);
            
            Lock lock = liveAccessManager.getLiveWriteLock();
            
            // Ensure write access to the live workspace is exclusive
            lock.lock();
    
            try
            {
                if (_logger.isDebugEnabled())
                {
                    _logger.debug("Live write lock has been acquired: " + lock);
                }
                
                Session liveSession = null;
                Session generationSession = null;
                
                // FIXME refactor with JCR 2.0 methods
                    
                try
                {
                    // Open a session to the workspace live
                    liveSession = repository.login(WebConstants.LIVE_WORKSPACE);
                    
                    try
                    {
                        generationSession = repository.login("generation");
                    }
                    catch (NoSuchWorkspaceException e)
                    {
                        // Not available with JCR 1.0 :(
                        ((JackrabbitWorkspace) liveSession.getWorkspace()).createWorkspace("generation");
                        generationSession = repository.login("generation");
                    }
                    
                    Node generationRootNode = generationSession.getRootNode();
                    NodeIterator itNode = generationRootNode.getNodes();
                    
                    // Remove workspace content
                    while (itNode.hasNext())
                    {
                        Node node = itNode.nextNode();
                        
                        if (!node.getName().equals("jcr:system"))
                        {
                            node.remove();
                        }
                    }
                    
                    // Commit changes 
                    generationSession.save();
                    
                    Node liveRootNode = liveSession.getRootNode();
                    
                    // Clone nodes
                    synchronizeComponent.cloneNodeAndPreserveUUID(liveRootNode, generationRootNode, PredicateUtils.truePredicate(), new Predicate()
                        {
                            @Override
                            public boolean evaluate(Object object)
                            {
                                if (object instanceof Node)
                                {
                                    try
                                    {
                                        return !((Node) object).getPath().equals("/jcr:system");
                                    }
                                    catch (RepositoryException e)
                                    {
                                        throw new RuntimeException(e);
                                    }
                                }
                                
                                return false;
                            }
                        });
                   
                    // Commit changes
                    generationSession.save();
                 
                    // Retrieve current workspace
                    Request request = ObjectModelHelper.getRequest(objectModel);
                    
                    String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
                    RenderingContext currentContext = _renderingContextHandler.getRenderingContext();

                    try
                    {
                        // Use live workspace
                        RequestAttributeWorkspaceSelector.setForcedWorkspace(request, "generation");
                        
                        // Set right rendering context
                        _renderingContextHandler.setRenderingContext(RenderingContext.FRONT);
                        
                        // Retrieve the site in the live workspace
                        Site liveSite = resolver.resolveById(site.getId());
                        
                        _generateSite(manager, objectModel, liveSite, tempOutputDir);
                    }
                    finally
                    {
                        // Restore context
                        RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
                        _renderingContextHandler.setRenderingContext(currentContext);
                    }
                }
                catch (Exception e)
                {
                    throw new Exception("Generation of site: " + site + " failed", e);
                }
                finally
                {
                    if (liveSession != null)
                    {
                        liveSession.logout();
                    }
                    if (generationSession != null)
                    {
                        generationSession.logout();
                    }
                }
            }
            finally
            {
                lock.unlock();
            }
        }
        catch (ServiceException e)
        {
            _logger.error("Unable to lookup for a component needed for the generation", e);
        }
    }

    private void _generateSite(ServiceManager manager, Map objectModel, Site site, File tempOutputDir) throws Exception
    {
        // Create environment
        // TODO change context depending on the site
        Context context = ObjectModelHelper.getContext(objectModel);
        GenerationEnvironment environment = new GenerationEnvironment(new SLF4JLoggerAdapter(_logger), context, "");
        Processor processor = (Processor) manager.lookup(Processor.ROLE);
        Object processingKey = CocoonComponentManager.startProcessing(environment);
        int environmentDepth = CocoonComponentManager.markEnvironment();
        CocoonComponentManager.enterEnvironment(environment, new WrapperComponentManager(manager), processor);

        try
        {
            // Clean directory first
            if (tempOutputDir.exists() && tempOutputDir.isDirectory())
            {
                FileUtils.cleanDirectory(tempOutputDir);
            }
            else
            {
                tempOutputDir.mkdirs();
            }
            
            // Generate sitemap.xml & use this sitemap.xml
            SourceResolver resolver = (SourceResolver) manager.lookup(SourceResolver.ROLE);

            try
            {
                String siteName = site.getName();
                
                // For each sitemap
                for (Sitemap sitemap : site.getSitemaps())
                {
                    if (_logger.isDebugEnabled())
                    {
                        _logger.debug("Processing sitemap: " + sitemap);
                    }
                    
                    String sitemapName = sitemap.getName();
                    
                    // Generate each page
                    for (Page page : sitemap.getChildrenPages())
                    {
                        _generatePage(resolver, tempOutputDir, siteName, sitemapName, page);
                    }
                }
            }
            finally
            {
                manager.release(resolver);
            }
            
            // Copy skin resources
            _copySkin(context, tempOutputDir);
            
            // Generate additional resources (at least error page in each language)
            _generationAdditionalResources(manager, site, tempOutputDir);
            
            // Execute script for pushing changes
            _pushChanges(site);
        }
        finally
        {
            CocoonComponentManager.leaveEnvironment();
            CocoonComponentManager.endProcessing(environment, processingKey);
            CocoonComponentManager.checkEnvironment(environmentDepth, new SLF4JLoggerAdapter(_logger));
            manager.release(processor);
        }
        
    }

    private void _generatePage(SourceResolver resolver, File tempOutputDir, String siteName, String sitemapName, Page page) throws AmetysRepositoryException, IOException, RepositoryException
    {
        if (_logger.isDebugEnabled())
        {
            _logger.debug("Processing page: " + page);
        }
        
        String pageContext = sitemapName + "/" + page.getPathInSitemap();
        
        switch (page.getType())
        {
            case LINK:
            case NODE:
                // No HTML rendering because of redirection
                break;
            case CONTAINER:
                // Add content binary metadata
                for (Zone zone : page.getZones())
                {
                    for (ZoneItem zoneItem : zone.getZoneItems())
                    {
                        switch (zoneItem.getType())
                        {
                            case SERVICE:
                                // No resources attached
                                break;
                            case CONTENT:
                                Content content = zoneItem.getContent();
                                
                                if (_logger.isDebugEnabled())
                                {
                                    _logger.debug("Processing resources of content: " + content);
                                }
                                
                                _generateResources(resolver, tempOutputDir, pageContext + "/_data", content.getMetadataHolder());
                                
                                break;
                            default:
                                break;
                        }
                    }
                }
                
                // Generate HTML rendering
                // TODO How to add pdf export ?
                _generateURI(resolver, tempOutputDir, "cocoon://" + siteName + "/" + pageContext + ".html", pageContext);
                break;
            default:
                break;
        }
        
        // Generate child pages
        for (Page childPage : page.getChildrenPages())
        {
            _generatePage(resolver, tempOutputDir, siteName, sitemapName, childPage);
        }
    }

    private void _copySkin(Context context, File tempOutputDir) throws IOException
    {
        // TODO Copy only used skin ?
        FileUtils.copyDirectoryToDirectory(new File(context.getRealPath("/skins")), tempOutputDir);
    }

    private void _generationAdditionalResources(ServiceManager manager, Site site, File tempOutputDir) throws Exception
    {
        AdditionalSiteResourcesProviderExtensionPoint addResourcesExtPt = (AdditionalSiteResourcesProviderExtensionPoint) manager.lookup(AdditionalSiteResourcesProviderExtensionPoint.ROLE);
        
        for (String extensionId : addResourcesExtPt.getExtensionsIds())
        {
            AdditionalSiteResourcesProvider resourcesProvider = addResourcesExtPt.getExtension(extensionId);
            
            if (_logger.isDebugEnabled())
            {
                _logger.debug("Processing resources provider: " + resourcesProvider);
            }
            
            resourcesProvider.addResources(site, tempOutputDir);
        }
    }

    private void _pushChanges(Site site) throws Exception
    {
        String shell = Config.getInstance().getValue("generation.shell");
        //shell = "/bin/echo";
        
        if (shell != null && shell.trim().length() != 0)
        {
            if (_logger.isInfoEnabled())
            {
                _logger.info("Creating process: " + shell);
            }

            Process process = Runtime.getRuntime().exec(shell + " " + site.getName());
            
            // Waiting for the process to finish
            int statusCode = process.waitFor();
            
            if (statusCode == 0)
            {
                if (_logger.isInfoEnabled())
                {
                    _logger.info("Process terminated correctly, generation successful");
                }
                
                if (_logger.isDebugEnabled())
                {
                    _logger.debug("Process output stream: " + IOUtils.toString(process.getInputStream(), StandardCharsets.UTF_8));
                    _logger.debug("Process error stream: " + IOUtils.toString(process.getErrorStream(), StandardCharsets.UTF_8));
                }
            }
            else
            {
                if (_logger.isWarnEnabled())
                {
                    _logger.warn("Shell terminated with an error, exit code: " + statusCode);
                    _logger.warn("Output stream: " + IOUtils.toString(process.getInputStream(), StandardCharsets.UTF_8));
                    _logger.warn("Error stream: " + IOUtils.toString(process.getErrorStream(), StandardCharsets.UTF_8));
                }
                
                throw new Exception("Process terminated with an error, exit code: " + statusCode);
            }
        }
        else
        {
            if (_logger.isInfoEnabled())
            {
                _logger.info("No process for pushing changes");
            }
        }
    }

    private void _generateResources(SourceResolver resolver, File tempOutputDir, String pageContext, CompositeMetadata compositeMetadata) throws IOException, RepositoryException
    {
        String resourcesContext = pageContext + "/_data";
        
        for (String metadataName : compositeMetadata.getMetadataNames())
        {
            switch (compositeMetadata.getType(metadataName))
            {
                case BINARY:
                    BinaryMetadata binaryMetadata = compositeMetadata.getBinaryMetadata(metadataName);
                    _copyResource(tempOutputDir, resourcesContext, binaryMetadata.getFilename(), binaryMetadata);
                    break;
                case RICHTEXT:
                    RichText richText = compositeMetadata.getRichText(metadataName);
                    Folder folder = richText.getAdditionalDataFolder();
                    _copyFolder(tempOutputDir, resourcesContext, folder);
                    break;
                case COMPOSITE:
                    _generateResources(resolver, tempOutputDir, resourcesContext, compositeMetadata);
                    break;
                default:
                    break;
            }
        }
        
    }

    private void _copyFolder(File tempOutputDir, String resourcesContext, Folder folder) throws AmetysRepositoryException, IOException, RepositoryException
    {
        for (org.ametys.plugins.repository.metadata.File file : folder.getFiles())
        {
            _copyResource(tempOutputDir, resourcesContext, file.getName(), file.getResource());
        }
        
        for (Folder subFolder : folder.getFolders())
        {
            _copyFolder(tempOutputDir, resourcesContext, subFolder);
        }
    }

    private void _copyResource(File tempOutputDir, String pageContext, String fileName, Resource resource) throws IOException, RepositoryException
    {
        String newFileName = fileName;
        
        if (newFileName == null)
        {
            newFileName = "data";
            // TODO found a library for computing extension from a mime-type
            String mimeType = resource.getMimeType();
            
            if (mimeType.equals("image/jpeg"))
            {
                newFileName += ".jpg";
            }
            else if (mimeType.equals("image/gif"))
            {
                newFileName += ".gif";
            }
            else if (mimeType.equals("image/png"))
            {
                newFileName += ".png";
            }
            else if (mimeType.equals("application/x-shockwave-flash"))
            {
                newFileName += ".swf";
            }
            else if (mimeType.equals("application/pdf"))
            {
                newFileName += ".pdf";
            }
            else if (mimeType.equals("application/msword"))
            {
                newFileName += ".doc";
            }
            else if (mimeType.equals("application/vnd.ms-excel"))
            {
                newFileName += ".xls";
            }
            else if (mimeType.equals("application/vnd.ms-powerpoint"))
            {
                newFileName += ".ppt";
            }
            else if (mimeType.equals("application/vnd.oasis.opendocument.text"))
            {
                newFileName += ".odt";
            }
            else if (mimeType.equals("application/zip"))
            {
                newFileName += ".zip";
            }
            else if (_logger.isWarnEnabled())
            {
                _logger.warn("Unknown mime-type: " + mimeType + ", using: " + newFileName);
            }
        }
        
        // TODO encode filename to avoid encoding/space problem ?
        
        String resourceDir = pageContext;
        
        if (resource instanceof JCRResource)
        {
            String uuid = ((JCRResource) resource).getNode().getIdentifier();
            resourceDir += "/" + uuid;
        }

        File output = new File(new File(tempOutputDir, resourceDir), fileName);
        output.getParentFile().mkdirs();
        try (InputStream is = resource.getInputStream(); OutputStream os = new FileOutputStream(output))
        {
            IOUtils.copy(is, os);
        }
    }

    private void _generateURI(SourceResolver resolver, File tempOutputDir, String uri, String destPath) throws IOException
    {
        Source source = resolver.resolveURI(uri);

        File output = new File(tempOutputDir, destPath);
        output.getParentFile().mkdirs();
        try (InputStream is = source.getInputStream(); OutputStream os = new FileOutputStream(output))
        {
            IOUtils.copy(is, os);
        }
    }
}