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

import java.io.InputStream;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
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.components.ContextHelper;
import org.apache.cocoon.environment.Request;

import org.ametys.cms.repository.Content;
import org.ametys.cms.transformation.ConsistencyChecker.CHECK;
import org.ametys.core.util.URLEncoder;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.metadata.CompositeMetadata;
import org.ametys.plugins.repository.metadata.File;
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.UnknownMetadataException;
import org.ametys.plugins.repository.version.VersionableAmetysObject;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.workspace.WorkspaceMatcher;

/**
 * {@link URIResolver} for resources local to a Content.
 */
public class LocalURIResolver extends AbstractLogEnabled implements URIResolver, Contextualizable, Serviceable
{
    /** The context */
    protected Context _context;
    /** The ametys object resolver */
    protected AmetysObjectResolver _ametysObjectResolver;

    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _ametysObjectResolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
    }
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public String getType()
    {
        return "local";
    }

    @Override
    public String resolve(String uri, boolean download, boolean absolute, boolean internal)
    {
        URIInfo infos = getInfos(uri, false);
        
        StringBuilder resultPath = new StringBuilder();
        
        resultPath.append(getUriPrefix(download, absolute, internal))
                  .append("/plugins/cms" + (download ? "/download/" : "/view/"))
                  .append(infos.getPath());
        
        Map<String, String> params = new HashMap<>();
        params.put("contentId", infos.getContentId());
        params.put("metadata", infos.getMetadata());
        if (infos.getContentVersion() != null)
        {
            params.put("contentVersion", infos.getContentVersion());
        }
        
        // Encode twice
        String encodedPath = URLEncoder.encodePath(resultPath.toString());
        return URLEncoder.encodeURI(encodedPath, params);
    }
    
    /**
     * Parses the uri.
     * @param uri the incoming uri.
     * @param resolveContent true if the Content should be actually resolved if not found in the request.
     * @return an object containing all parsed infos.
     */
    protected URIInfo getInfos(String uri, boolean resolveContent)
    {
        // uri are like content://UUID@metadata;data/file.ext
        int i = uri.indexOf('@');
        int j = uri.indexOf(';', i);
        String id = uri.substring(0, i);
        String metadata = uri.substring(i + 1, j);
        String path = uri.substring(j + 1);

        Request request = ContextHelper.getRequest(_context);
        
        String contentVersion = null;
        // The content should be the one from request (UUID) but in that case, getRevision will be always the head on
        Content content = (Content) request.getAttribute(Content.class.getName()); 
        if (content == null || !id.equals(content.getId()))
        {
            // Some time (such as frontoffice edition) the image is rendered with no content in attrbiute
            content = resolveContent ? _ametysObjectResolver.resolveById(id) : null;
        }
        else
        {
            contentVersion = ((VersionableAmetysObject) content).getRevision();
        }
        
        URIInfo infos = new URIInfo();
        infos.setContentId(id);
        infos.setContentVersion(contentVersion);
        infos.setMetadata(metadata);
        infos.setPath(path);
        infos.setContent(content);
        
        return infos;
    }
    
    /**
     * Get the URI prefix
     * @param download true if the pointed resource is to be downloaded.
     * @param absolute true if the url must be absolute
     * @param internal true to get an internal URI.
     * @return the URI prefix
     */
    protected String getUriPrefix (boolean download, boolean absolute, boolean internal)
    {
        if (internal)
        {
            return "cocoon://";
        }
        else 
        {
            Request request = ContextHelper.getRequest(_context);
            String workspaceURI = (String) request.getAttribute(WorkspaceMatcher.WORKSPACE_URI);
            String uriPrefix = request.getContextPath() + workspaceURI;
            
            if (absolute && !uriPrefix.startsWith(request.getScheme()))
            {
                uriPrefix = request.getScheme() + "://" + request.getServerName() + (request.getServerPort() != 80 ? ":" + request.getServerPort() : "") + uriPrefix;
            }
            
            return uriPrefix;
        }
    }
    
    @Override
    public String resolveImage(String uri, int height, int width, boolean download, boolean absolute, boolean internal)
    {
        throw new UnsupportedOperationException("resolveImage");
    }
    
    @Override
    public String resolveImageAsBase64(String uri, int height, int width)
    {
        return resolveImageAsBase64(uri, height, width, 0, 0, 0, 0);
    }
    
    @Override
    public String resolveBoundedImage(String uri, int maxHeight, int maxWidth, boolean download, boolean absolute, boolean internal)
    {
        throw new UnsupportedOperationException("resolveBoundedImage");
    }
    
    @Override
    public String resolveBoundedImageAsBase64(String uri, int maxHeight, int maxWidth)
    {
        return resolveImageAsBase64(uri, 0, 0, maxHeight, maxWidth, 0, 0);
    }
    
    @Override
    public String resolveCroppedImage(String uri, int cropHeight, int cropWidth, boolean download, boolean absolute, boolean internal)
    {
        throw new UnsupportedOperationException("resolveCroppedImage");
    }
    
    @Override
    public String resolveCroppedImageAsBase64(String uri, int cropHeight, int cropWidth)
    {
        return resolveImageAsBase64(uri, 0, 0, 0, 0, cropHeight, cropWidth);
    }
    
    /**
     * Get an image's bytes encoded as base64, optionally resized. 
     * @param uri the image URI.
     * @param height the specified height. Ignored if negative.
     * @param width the specified width. Ignored if negative.
     * @param maxHeight the maximum image height. Ignored if height or width is specified.
     * @param maxWidth the maximum image width. Ignored if height or width is specified.
     * @param cropHeight The cropping height. Ignored if negative.
     * @param cropWidth The cropping width. Ignored if negative.
     * @return the image bytes encoded as base64.
     */
    protected String resolveImageAsBase64(String uri, int height, int width, int maxHeight, int maxWidth, int cropHeight, int cropWidth)
    {
        URIInfo infos = getInfos(uri, true);
        
        try
        {
            RichText richText = _getMeta(infos.getContent().getMetadataHolder(), infos.getMetadata());
            File file = _getFile(richText.getAdditionalDataFolder(), infos.getPath());
            Resource resource = file.getResource();
            
            try (InputStream dataIs = resource.getInputStream())
            {
                return ImageResolverHelper.resolveImageAsBase64(dataIs, resource.getMimeType(), height, width, maxHeight, maxWidth, cropHeight, cropWidth);
            }
        }
        catch (Exception e)
        {
            throw new IllegalStateException(e);
        }
    }
    
    @Override
    public CHECK checkLink(String uri, boolean shortTest)
    {
        try
        {
            int i = uri.indexOf('@');
            int j = uri.indexOf(';', i);
            
            if (i == -1 || j == -1)
            {
                getLogger().warn("Failed to check local URI: '" + uri + " does not respect the excepted format 'content://UUID@metadata;data/file.ext'");
                return CHECK.SERVER_ERROR;
            }
            
            String id = uri.substring(0, i);
            String metadata = uri.substring(i + 1, j);
            String fileName = uri.substring(j + 1);
            
            Content content = _ametysObjectResolver.resolveById(id);
            RichText richText = _getMeta(content.getMetadataHolder(), metadata);
            
            richText.getAdditionalDataFolder().getFile(fileName);
            
            return CHECK.SUCCESS;
        }
        catch (UnknownMetadataException e)
        {
            return CHECK.NOT_FOUND;
        }
        catch (Exception e)
        {
            throw new RuntimeException("Cannot check the uri '" + uri + "'", e);
        }
    }
    
    @Override
    public I18nizableText getLabel(String uri)
    {
        int i = uri.indexOf('@');
        int j = uri.indexOf(';', i);
        
        String fileName = uri.substring(j + 1);
        
        return new I18nizableText("plugin.cms", "PLUGINS_CMS_LINK_LOCAL_LABEL", Collections.singletonList(fileName));
    }
    
    /**
     * Get the rich text meta
     * @param meta The composite meta
     * @param metadataName The metadata name (with /)
     * @return The rich text meta
     */
    protected RichText _getMeta(CompositeMetadata meta, String metadataName)
    {
        int pos = metadataName.indexOf("/");
        if (pos == -1)
        {
            return meta.getRichText(metadataName);
        }
        else
        {
            return _getMeta(meta.getCompositeMetadata(metadataName.substring(0, pos)), metadataName.substring(pos + 1));
        }
    }
    
    /**
     * Get the file at the specified path in the given folder.
     * @param folder The folder to search in.
     * @param path The file path in the folder (can contain slashes).
     * @return The file if found, null otherwise.
     */
    protected File _getFile(Folder folder, String path)
    {
        File file = null;
        
        Iterator<String> it = Arrays.asList(path.split("/")).iterator();
        
        Folder browsedFolder = folder;
        while (it.hasNext())
        {
            String pathElement = it.next();
            
            if (it.hasNext())
            {
                // not the last segment : it is a composite
                browsedFolder = browsedFolder.getFolder(pathElement);
            }
            else
            {
                file = browsedFolder.getFile(pathElement);
            }
        }
        
        return file;
    }
    
    /**
     * Helper class containg all infos parsed from URI.
     */
    protected static class URIInfo
    {
        /** The content id. */
        private String _contentId;
        /** The relevant attribute */
        private String _metadata;
        /** The path to the resource */
        private String _path;
        /** The content version, if any. */
        private String _contentVersion;
        /** The resolved content, if any. */
        private Content _content;
        
        /**
         * Returns the content id.
         * @return the content id.
         */
        public String getContentId()
        {
            return _contentId;
        }
        
        /**
         * Set the content id.
         * @param contentId the content id.
         */
        public void setContentId(String contentId)
        {
            _contentId = contentId;
        }
        
        /**
         * Returns the metadata.
         * @return the metadata.
         */
        public String getMetadata()
        {
            return _metadata;
        }
        
        /**
         * Set the metadata.
         * @param metadata the metadata.
         */
        public void setMetadata(String metadata)
        {
            _metadata = metadata;
        }
        
        /**
         * Returns the resource path.
         * @return the path
         */
        public String getPath()
        {
            return _path;
        }
        
        /**
         * Set the resource path.
         * @param path the path.
         */
        public void setPath(String path)
        {
            _path = path;
        }
        
        /**
         * Returns the content version, if any.
         * @return the content version.
         */
        public String getContentVersion()
        {
            return _contentVersion;
        }
        
        /**
         * Set the content version.
         * @param contentVersion the content version.
         */
        public void setContentVersion(String contentVersion)
        {
            _contentVersion = contentVersion;
        }
        
        /**
         * Returns the resolved content, if any.
         * @return the content.
         */
        public Content getContent()
        {
            return _content;
        }
        
        /**
         * Set the content.
         * @param content the content.
         */
        public void setContent(Content content)
        {
            _content = content;
        }
    }
}