/*
 *  Copyright 2017 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.remote;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

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.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.apache.commons.lang.StringUtils;

import org.ametys.cms.transformation.ConsistencyChecker.CHECK;
import org.ametys.cms.transformation.URIResolver;
import org.ametys.cms.transformation.URIResolverExtensionPoint;
import org.ametys.cms.transformation.xslt.ResolveURIComponent;
import org.ametys.runtime.config.Config;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.workspace.WorkspaceMatcher;


/**
 * {@link URIResolver} for type "remote".<br>
 * This resolver is a proxy to another type to be called from remote url.
 * The resolved uri are necessary absolutes.
 */
public class RemoteURIResolver implements URIResolver, Serviceable, Contextualizable
{
    private static final Pattern __URI_PATTERN = Pattern.compile("([^;]*);(.*)");
    
    /** The context */
    protected Context _context;
    
    /** The ametys uri resolver */
    protected URIResolverExtensionPoint _uriResolverEP;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _uriResolverEP = (URIResolverExtensionPoint) manager.lookup(URIResolverExtensionPoint.ROLE);
    }
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public String getType()
    {
        return "remote";
    }

    @Override
    public String resolve(String uri, boolean download, boolean absolute, boolean internal)
    {
        Request request = ContextHelper.getRequest(_context);
        
        ProxiedUri proxiedUri = getProxiedUri(uri);
        
        return getAbsoluteRemoteUri(request, ResolveURIComponent.resolve(proxiedUri.getType(), proxiedUri.getUri(), download, false, false));
    }

    @Override
    public String resolveImage(String uri, int height, int width, boolean download, boolean absolute, boolean internal)
    {
        Request request = ContextHelper.getRequest(_context);
        
        ProxiedUri proxiedUri = getProxiedUri(uri);
        
        return getAbsoluteRemoteUri(request, ResolveURIComponent.resolveImage(proxiedUri.getType(), proxiedUri.getUri(), height, width, download, false, false));
    }

    @Override
    public String resolveImageAsBase64(String uri, int height, int width)
    {
        Request request = ContextHelper.getRequest(_context);
        
        ProxiedUri proxiedUri = getProxiedUri(uri);
        
        return getAbsoluteRemoteUri(request, ResolveURIComponent.resolveImage(proxiedUri.getType(), proxiedUri.getUri(), height, width));
    }

    @Override
    public String resolveBoundedImage(String uri, int maxHeight, int maxWidth, boolean download, boolean absolute, boolean internal)
    {
        Request request = ContextHelper.getRequest(_context);
        
        ProxiedUri proxiedUri = getProxiedUri(uri);
        
        return getAbsoluteRemoteUri(request, ResolveURIComponent.resolveBoundedImage(proxiedUri.getType(), proxiedUri.getUri(), maxHeight, maxWidth, download, false, false));
    }

    @Override
    public String resolveBoundedImageAsBase64(String uri, int maxHeight, int maxWidth)
    {
        Request request = ContextHelper.getRequest(_context);
        
        ProxiedUri proxiedUri = getProxiedUri(uri);
        
        return getAbsoluteRemoteUri(request, ResolveURIComponent.resolveBoundedImage(proxiedUri.getType(), proxiedUri.getUri(), maxHeight, maxWidth));
    }

    @Override
    public String resolveCroppedImage(String uri, int cropHeight, int cropWidth, boolean download, boolean absolute, boolean internal)
    {
        Request request = ContextHelper.getRequest(_context);
        
        ProxiedUri proxiedUri = getProxiedUri(uri);
        
        return getAbsoluteRemoteUri(request, ResolveURIComponent.resolveCroppedImage(proxiedUri.getType(), proxiedUri.getUri(), cropHeight, cropWidth, download, false, false));
    }

    @Override
    public String resolveCroppedImageAsBase64(String uri, int cropHeight, int cropWidth)
    {
        Request request = ContextHelper.getRequest(_context);
        
        ProxiedUri proxiedUri = getProxiedUri(uri);
        
        return getAbsoluteRemoteUri(request, ResolveURIComponent.resolveCroppedImage(proxiedUri.getType(), proxiedUri.getUri(), cropHeight, cropWidth));
    }

    @Override
    public CHECK checkLink(String uri, boolean shortTest)
    {
        ProxiedUri proxiedUri = getProxiedUri(uri);

        URIResolver resolver = _uriResolverEP.getResolverForType(proxiedUri.getType());
        if (resolver != null)
        {
            return resolver.checkLink(proxiedUri.getUri(), shortTest);
        }
        
        return CHECK.NOT_FOUND;
    }

    @Override
    public I18nizableText getLabel(String uri)
    {
        ProxiedUri proxiedUri = getProxiedUri(uri);
        URIResolver resolver = _uriResolverEP.getResolverForType(proxiedUri.getType());
        if (resolver != null)
        {
            I18nizableText label = resolver.getLabel(proxiedUri.getUri());
            Map<String, I18nizableText> params = new HashMap<>();
            params.put("uri", label);
            return new I18nizableText("plugin.cms", "PLUGINS_CMS_LINK_REMOTE_LABEL", params);
        }
        
        return new I18nizableText("plugin.cms", "PLUGINS_CMS_LINK_REMOTE_UNKNOWN_TYPE", Collections.singletonList(proxiedUri.getType()));
    }
    
    /**
     * Get the absolute proxied uri
     * @param request the request
     * @param resolvedUri the resolved uri
     * @return the absolute proxied url
     */
    protected String getAbsoluteRemoteUri(Request request, String resolvedUri)
    {
        String uriPrefix = getUriPrefix(request);
        return getAbsoluteRemoteUriPrefix() + (resolvedUri.startsWith(uriPrefix) ? StringUtils.substringAfter(resolvedUri, uriPrefix) : resolvedUri);
    }
    
    
    /**
     * Get the absolute URI prefix
     * @return the URI prefix
     */
    protected String getAbsoluteRemoteUriPrefix()
    {
        StringBuilder result = new StringBuilder();
        
        String cmsUrl = Config.getInstance().getValueAsString("cms.url");
        
        result.append(cmsUrl)
            .append(cmsUrl.endsWith("/") ? "" : "/")
            .append("_cms/remote");
            
        return result.toString();
    }
    
    /**
     * Get the URI prefix (non absolute) for resolved uri
     * @param request The request
     * @return the URI prefix
     */
    protected String getUriPrefix(Request request)
    {
        String workspaceURI = (String) request.getAttribute(WorkspaceMatcher.WORKSPACE_URI);
        return request.getContextPath() + workspaceURI;
    }
    
    /**
     * Get the proxied uri
     * @param uri The requested uri
     * @return the proxied uri or null
     * @throws IllegalArgumentException The uri does match the expected pattern
     */
    protected ProxiedUri getProxiedUri(String uri) throws IllegalArgumentException
    {
        Matcher matcher = __URI_PATTERN.matcher(uri);
        if (matcher.matches())
        {
            String type = matcher.group(1);
            String initialUri = matcher.group(2);

            return new ProxiedUri(type, initialUri);
        }
        
        throw new IllegalArgumentException("The uri " + uri + " does not match the regular expression " + __URI_PATTERN.pattern());
    }
    
    /**
     * Proxied URI
     *
     */
    protected class ProxiedUri
    {
        private String _uri;
        private String _type;
        
        /**
         * Constructor
         * @param type The type
         * @param uri The uri to proxy
         */
        public ProxiedUri(String type, String uri)
        {
            _type = type;
            _uri = uri;
        }
        
        /**
         * Get the uri
         * @return the uri
         */
        public String getUri()
        {
            return _uri;
        }
        
        
        /**
         * Get the object.
         * @return the object
         */
        public String getType()
        {
            return _type;
        }
    }

}