/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.apache.chemistry.opencmis.client.bindings.spi.webservices;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.SoftReference;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.math.BigInteger;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayDeque;
import java.util.Collections;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReentrantLock;

import javax.xml.namespace.QName;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.ws.BindingProvider;
import javax.xml.ws.Service;
import javax.xml.ws.WebServiceFeature;
import javax.xml.ws.handler.HandlerResolver;
import javax.xml.ws.handler.MessageContext;
import javax.xml.ws.http.HTTPException;

import org.apache.chemistry.opencmis.client.bindings.impl.ClientVersion;
import org.apache.chemistry.opencmis.client.bindings.impl.CmisBindingsHelper;
import org.apache.chemistry.opencmis.client.bindings.spi.BindingSession;
import org.apache.chemistry.opencmis.client.bindings.spi.http.HttpInvoker;
import org.apache.chemistry.opencmis.client.bindings.spi.http.Response;
import org.apache.chemistry.opencmis.commons.SessionParameter;
import org.apache.chemistry.opencmis.commons.enums.CmisVersion;
import org.apache.chemistry.opencmis.commons.exceptions.CmisBaseException;
import org.apache.chemistry.opencmis.commons.exceptions.CmisConnectionException;
import org.apache.chemistry.opencmis.commons.exceptions.CmisObjectNotFoundException;
import org.apache.chemistry.opencmis.commons.exceptions.CmisProxyAuthenticationException;
import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException;
import org.apache.chemistry.opencmis.commons.exceptions.CmisUnauthorizedException;
import org.apache.chemistry.opencmis.commons.impl.IOUtils;
import org.apache.chemistry.opencmis.commons.impl.UrlBuilder;
import org.apache.chemistry.opencmis.commons.impl.XMLUtils;
import org.apache.chemistry.opencmis.commons.impl.jaxb.ACLService;
import org.apache.chemistry.opencmis.commons.impl.jaxb.ACLServicePort;
import org.apache.chemistry.opencmis.commons.impl.jaxb.DiscoveryService;
import org.apache.chemistry.opencmis.commons.impl.jaxb.DiscoveryServicePort;
import org.apache.chemistry.opencmis.commons.impl.jaxb.MultiFilingService;
import org.apache.chemistry.opencmis.commons.impl.jaxb.MultiFilingServicePort;
import org.apache.chemistry.opencmis.commons.impl.jaxb.NavigationService;
import org.apache.chemistry.opencmis.commons.impl.jaxb.NavigationServicePort;
import org.apache.chemistry.opencmis.commons.impl.jaxb.ObjectService;
import org.apache.chemistry.opencmis.commons.impl.jaxb.ObjectServicePort;
import org.apache.chemistry.opencmis.commons.impl.jaxb.PolicyService;
import org.apache.chemistry.opencmis.commons.impl.jaxb.PolicyServicePort;
import org.apache.chemistry.opencmis.commons.impl.jaxb.RelationshipService;
import org.apache.chemistry.opencmis.commons.impl.jaxb.RelationshipServicePort;
import org.apache.chemistry.opencmis.commons.impl.jaxb.RepositoryService;
import org.apache.chemistry.opencmis.commons.impl.jaxb.RepositoryServicePort;
import org.apache.chemistry.opencmis.commons.impl.jaxb.VersioningService;
import org.apache.chemistry.opencmis.commons.impl.jaxb.VersioningServicePort;
import org.apache.chemistry.opencmis.commons.spi.AuthenticationProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public abstract class AbstractPortProvider {

    private static final Logger LOG = LoggerFactory.getLogger(AbstractPortProvider.class);

    private static final int PORT_CACHE_SIZE = 5;

    protected static final int CHUNK_SIZE = (64 * 1024) - 1;

    protected enum CmisWebSerivcesService {
        REPOSITORY_SERVICE("RepositoryService", false, RepositoryService.class, RepositoryServicePort.class,
                SessionParameter.WEBSERVICES_REPOSITORY_SERVICE,
                SessionParameter.WEBSERVICES_REPOSITORY_SERVICE_ENDPOINT),

        NAVIGATION_SERVICE("NavigationService", false, NavigationService.class, NavigationServicePort.class,
                SessionParameter.WEBSERVICES_NAVIGATION_SERVICE,
                SessionParameter.WEBSERVICES_NAVIGATION_SERVICE_ENDPOINT),

        OBJECT_SERVICE("ObjectService", true, ObjectService.class, ObjectServicePort.class,
                SessionParameter.WEBSERVICES_OBJECT_SERVICE, SessionParameter.WEBSERVICES_OBJECT_SERVICE_ENDPOINT),

        VERSIONING_SERVICE("VersioningService", true, VersioningService.class, VersioningServicePort.class,
                SessionParameter.WEBSERVICES_VERSIONING_SERVICE,
                SessionParameter.WEBSERVICES_VERSIONING_SERVICE_ENDPOINT),

        DISCOVERY_SERVICE("DiscoveryService", false, DiscoveryService.class, DiscoveryServicePort.class,
                SessionParameter.WEBSERVICES_DISCOVERY_SERVICE, SessionParameter.WEBSERVICES_DISCOVERY_SERVICE_ENDPOINT),

        MULTIFILING_SERVICE("MultiFilingService", false, MultiFilingService.class, MultiFilingServicePort.class,
                SessionParameter.WEBSERVICES_MULTIFILING_SERVICE,
                SessionParameter.WEBSERVICES_MULTIFILING_SERVICE_ENDPOINT),

        RELATIONSHIP_SERVICE("RelationshipService", false, RelationshipService.class, RelationshipServicePort.class,
                SessionParameter.WEBSERVICES_RELATIONSHIP_SERVICE,
                SessionParameter.WEBSERVICES_RELATIONSHIP_SERVICE_ENDPOINT),

        POLICY_SERVICE("PolicyService", false, PolicyService.class, PolicyServicePort.class,
                SessionParameter.WEBSERVICES_POLICY_SERVICE, SessionParameter.WEBSERVICES_POLICY_SERVICE_ENDPOINT),

        ACL_SERVICE("ACLService", false, ACLService.class, ACLServicePort.class,
                SessionParameter.WEBSERVICES_ACL_SERVICE, SessionParameter.WEBSERVICES_ACL_SERVICE_ENDPOINT);

        private final String name;
        private final QName qname;
        private final boolean handlesContent;
        private final Class<? extends Service> serviceClass;
        private final Class<?> portClass;
        private final String wsdlKey;
        private final String endpointKey;

        CmisWebSerivcesService(String localname, boolean handlesContent, Class<? extends Service> serviceClass,
                Class<?> port11Class, String wsdlKey, String endpointKey) {
            this.name = localname;
            this.qname = new QName("http://docs.oasis-open.org/ns/cmis/ws/200908/", localname);
            this.handlesContent = handlesContent;
            this.serviceClass = serviceClass;
            this.portClass = port11Class;
            this.wsdlKey = wsdlKey;
            this.endpointKey = endpointKey;
        }

        public String getServiceName() {
            return name;
        }

        public QName getQName() {
            return qname;
        }

        public boolean handlesContent() {
            return handlesContent;
        }

        public Class<? extends Service> getServiceClass() {
            return serviceClass;
        }

        public Class<?> getPortClass() {
            return portClass;
        }

        public String getWsdlKey() {
            return wsdlKey;
        }

        public String getEndpointKey() {
            return endpointKey;
        }
    }

    class CmisServiceHolder {
        private final CmisWebSerivcesService service;
        private SoftReference<Service> serviceObject;
        private final URL endpointUrl;

        public CmisServiceHolder(final CmisWebSerivcesService service, final URL endpointUrl)
                throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
            this.service = service;
            this.endpointUrl = endpointUrl;
            this.serviceObject = new SoftReference<Service>(createServiceObject());
        }

        private Service createServiceObject() throws InstantiationException, IllegalAccessException,
                InvocationTargetException, NoSuchMethodException {
            final Constructor<? extends Service> serviceConstructor = service.getServiceClass().getConstructor(
                    new Class<?>[] { URL.class, QName.class });

            URL wsdlUrl = service.getPortClass().getResource("/wsdl/cmis11/CMISWS-Service.wsdl");
            if (LOG.isDebugEnabled()) {
                LOG.debug("Session {}: WSDL URL: {}", getSession().getSessionId(), wsdlUrl.toExternalForm());
            }

            Service newService = serviceConstructor.newInstance(new Object[] { wsdlUrl, service.getQName() });

            AuthenticationProvider authProvider = CmisBindingsHelper.getAuthenticationProvider(getSession());
            if (authProvider != null) {
                HandlerResolver handlerResolver = authProvider.getHandlerResolver();
                if (handlerResolver != null) {
                    newService.setHandlerResolver(handlerResolver);
                }
            }

            return newService;
        }

        public CmisWebSerivcesService getService() {
            return service;
        }

        public Service getServiceObject() throws InstantiationException, IllegalAccessException,
                InvocationTargetException, NoSuchMethodException {
            Service result = serviceObject.get();
            if (result == null) {
                result = createServiceObject();
                serviceObject = new SoftReference<Service>(result);
            }

            return result;
        }

        public URL getEndpointUrl() {
            return endpointUrl;
        }

        public String getServiceName() {
            return service.getServiceName();
        }
    }

    private BindingSession session;
    private boolean useCompression;
    private boolean useClientCompression;
    private String acceptLanguage;

    private final ReentrantLock portObjectLock = new ReentrantLock();
    private final EnumMap<CmisWebSerivcesService, ArrayDeque<SoftReference<BindingProvider>>> portObjectCache = new EnumMap<CmisWebSerivcesService, ArrayDeque<SoftReference<BindingProvider>>>(
            CmisWebSerivcesService.class);

    public BindingSession getSession() {
        return session;
    }

    public void setSession(BindingSession session) {
        this.session = session;

        final Object compression = session.get(SessionParameter.COMPRESSION);
        useCompression = (compression != null) && Boolean.parseBoolean(compression.toString());

        final Object clientCompression = session.get(SessionParameter.CLIENT_COMPRESSION);
        useClientCompression = (clientCompression != null) && Boolean.parseBoolean(clientCompression.toString());

        if (session.get(CmisBindingsHelper.ACCEPT_LANGUAGE) instanceof String) {
            acceptLanguage = session.get(CmisBindingsHelper.ACCEPT_LANGUAGE).toString();
        }
    }

    public boolean useCompression() {
        return useCompression;
    }

    public boolean useClientCompression() {
        return useClientCompression;
    }

    public String getAcceptLanguage() {
        return acceptLanguage;
    }

    /**
     * Return the Repository Service port object.
     */
    public RepositoryServicePort getRepositoryServicePort(CmisVersion cmisVersion, String soapAction) {
        BindingProvider portObject = getPortObject(CmisWebSerivcesService.REPOSITORY_SERVICE);
        setSoapAction(portObject, soapAction, cmisVersion);

        return (RepositoryServicePort) portObject;
    }

    /**
     * Return the Navigation Service port object.
     */
    public NavigationServicePort getNavigationServicePort(CmisVersion cmisVersion, String soapAction) {
        BindingProvider portObject = getPortObject(CmisWebSerivcesService.NAVIGATION_SERVICE);
        setSoapAction(portObject, soapAction, cmisVersion);

        return (NavigationServicePort) portObject;
    }

    /**
     * Return the Object Service port object.
     */
    public ObjectServicePort getObjectServicePort(CmisVersion cmisVersion, String soapAction) {
        BindingProvider portObject = getPortObject(CmisWebSerivcesService.OBJECT_SERVICE);
        setSoapAction(portObject, soapAction, cmisVersion);

        return (ObjectServicePort) portObject;
    }

    /**
     * Return the Versioning Service port object.
     */
    public VersioningServicePort getVersioningServicePort(CmisVersion cmisVersion, String soapAction) {
        BindingProvider portObject = getPortObject(CmisWebSerivcesService.VERSIONING_SERVICE);
        setSoapAction(portObject, soapAction, cmisVersion);

        return (VersioningServicePort) portObject;
    }

    /**
     * Return the Discovery Service port object.
     */
    public DiscoveryServicePort getDiscoveryServicePort(CmisVersion cmisVersion, String soapAction) {
        BindingProvider portObject = getPortObject(CmisWebSerivcesService.DISCOVERY_SERVICE);
        setSoapAction(portObject, soapAction, cmisVersion);

        return (DiscoveryServicePort) portObject;
    }

    /**
     * Return the MultiFiling Service port object.
     */
    public MultiFilingServicePort getMultiFilingServicePort(CmisVersion cmisVersion, String soapAction) {
        BindingProvider portObject = getPortObject(CmisWebSerivcesService.MULTIFILING_SERVICE);
        setSoapAction(portObject, soapAction, cmisVersion);

        return (MultiFilingServicePort) portObject;
    }

    /**
     * Return the Relationship Service port object.
     */
    public RelationshipServicePort getRelationshipServicePort(CmisVersion cmisVersion, String soapAction) {
        BindingProvider portObject = getPortObject(CmisWebSerivcesService.RELATIONSHIP_SERVICE);
        setSoapAction(portObject, soapAction, cmisVersion);

        return (RelationshipServicePort) portObject;
    }

    /**
     * Return the Policy Service port object.
     */
    public PolicyServicePort getPolicyServicePort(CmisVersion cmisVersion, String soapAction) {
        BindingProvider portObject = getPortObject(CmisWebSerivcesService.POLICY_SERVICE);
        setSoapAction(portObject, soapAction, cmisVersion);

        return (PolicyServicePort) portObject;
    }

    /**
     * Return the ACL Service port object.
     */
    public ACLServicePort getACLServicePort(CmisVersion cmisVersion, String soapAction) {
        BindingProvider portObject = getPortObject(CmisWebSerivcesService.ACL_SERVICE);
        setSoapAction(portObject, soapAction, cmisVersion);

        return (ACLServicePort) portObject;
    }

    public void endCall(Object portObject) {
        AuthenticationProvider authProvider = CmisBindingsHelper.getAuthenticationProvider(session);
        if (authProvider != null && portObject instanceof BindingProvider) {
            BindingProvider bp = (BindingProvider) portObject;
            String url = (String) bp.getRequestContext().get(BindingProvider.ENDPOINT_ADDRESS_PROPERTY);
            if (bp.getResponseContext() != null) {
                @SuppressWarnings("unchecked")
                Map<String, List<String>> headers = (Map<String, List<String>>) bp.getResponseContext().get(
                        MessageContext.HTTP_RESPONSE_HEADERS);
                Integer statusCode = (Integer) bp.getResponseContext().get(MessageContext.HTTP_RESPONSE_CODE);
                authProvider.putResponseHeaders(url, statusCode == null ? -1 : statusCode, headers);
            }

            CmisWebSerivcesService service = null;

            if (portObject instanceof RepositoryServicePort) {
                service = CmisWebSerivcesService.REPOSITORY_SERVICE;
            } else if (portObject instanceof NavigationServicePort) {
                service = CmisWebSerivcesService.NAVIGATION_SERVICE;
            } else if (portObject instanceof ObjectServicePort) {
                service = CmisWebSerivcesService.OBJECT_SERVICE;
            } else if (portObject instanceof VersioningServicePort) {
                service = CmisWebSerivcesService.VERSIONING_SERVICE;
            } else if (portObject instanceof DiscoveryServicePort) {
                service = CmisWebSerivcesService.DISCOVERY_SERVICE;
            } else if (portObject instanceof MultiFilingServicePort) {
                service = CmisWebSerivcesService.MULTIFILING_SERVICE;
            } else if (portObject instanceof RelationshipServicePort) {
                service = CmisWebSerivcesService.RELATIONSHIP_SERVICE;
            } else if (portObject instanceof PolicyServicePort) {
                service = CmisWebSerivcesService.POLICY_SERVICE;
            } else if (portObject instanceof ACLServicePort) {
                service = CmisWebSerivcesService.ACL_SERVICE;
            }

            if (service == null) {
                return;
            }

            portObjectLock.lock();
            try {
                ArrayDeque<SoftReference<BindingProvider>> queue = portObjectCache.get(service);
                if (queue == null) {
                    throw new CmisRuntimeException("This is a bug!");
                }

                if (queue.size() < PORT_CACHE_SIZE) {
                    queue.push(new SoftReference<BindingProvider>(bp));
                } else {
                    Iterator<SoftReference<BindingProvider>> iter = queue.iterator();
                    while (iter.hasNext()) {
                        SoftReference<BindingProvider> ref = iter.next();
                        if (ref.get() == null) {
                            iter.remove();
                            queue.push(new SoftReference<BindingProvider>(bp));
                            break;
                        }
                    }
                }
            } finally {
                portObjectLock.unlock();
            }
        }
    }

    // ---- internal ----

    @SuppressWarnings("unchecked")
    protected BindingProvider getPortObject(final CmisWebSerivcesService service) {
        Map<CmisWebSerivcesService, CmisServiceHolder> serviceMap = (Map<CmisWebSerivcesService, CmisServiceHolder>) session
                .get(SpiSessionParameter.SERVICES);

        // does the service map exist?
        if (serviceMap == null) {
            session.writeLock();
            try {
                // try again
                serviceMap = (Map<CmisWebSerivcesService, CmisServiceHolder>) session.get(SpiSessionParameter.SERVICES);
                if (serviceMap == null) {
                    serviceMap = new EnumMap<CmisWebSerivcesService, CmisServiceHolder>(CmisWebSerivcesService.class);
                    session.put(SpiSessionParameter.SERVICES, serviceMap, true);
                }

                if (serviceMap.containsKey(service)) {
                    return createPortObject(serviceMap.get(service));
                }

                // create service object
                CmisServiceHolder serviceholder = initServiceObject(service);
                serviceMap.put(service, serviceholder);

                // create port object
                return createPortObject(serviceholder);
            } finally {
                session.writeUnlock();
            }
        }

        // is the service in the service map?
        if (!serviceMap.containsKey(service)) {
            session.writeLock();
            try {
                // try again
                if (serviceMap.containsKey(service)) {
                    return createPortObject(serviceMap.get(service));
                }

                // create object
                CmisServiceHolder serviceholder = initServiceObject(service);
                serviceMap.put(service, serviceholder);

                return createPortObject(serviceholder);
            } finally {
                session.writeUnlock();
            }
        }

        return createPortObject(serviceMap.get(service));
    }

    /**
     * Creates a service object.
     */
    protected CmisServiceHolder initServiceObject(final CmisWebSerivcesService service) {
        if (LOG.isDebugEnabled()) {
            LOG.debug("Session {}: Initializing Web Service {} ...", getSession().getSessionId(),
                    service.getServiceName());
        }

        try {
            // get URLs
            URL endpointUrl = null;

            String wsdlUrlStr = (String) session.get(service.getWsdlKey());
            if (wsdlUrlStr != null) {
                endpointUrl = getEndpointUrlFromWsdl(wsdlUrlStr, service);
            } else {
                String endpointUrlStr = (String) session.get(service.getEndpointKey());
                if (endpointUrlStr != null) {
                    endpointUrl = new URL(endpointUrlStr);
                }
            }

            if (endpointUrl == null) {
                throw new CmisRuntimeException("Neither a WSDL URL nor an endpoint URL is specified for the service "
                        + service.getServiceName() + "!");
            }

            // build the requested service object
            return new CmisServiceHolder(service, endpointUrl);
        } catch (CmisBaseException ce) {
            throw ce;
        } catch (HTTPException he) {
            String message = "Cannot connect to Web Services [" + service.getServiceName() + "]: " + he.getMessage();
            if (he.getStatusCode() == 401) {
                throw new CmisUnauthorizedException(message, he);
            } else if (he.getStatusCode() == 404) {
                throw new CmisObjectNotFoundException(message, he);
            } else if (he.getStatusCode() == 407) {
                throw new CmisProxyAuthenticationException(message, he);
            } else if (he.getStatusCode() == 301 || he.getStatusCode() == 302 || he.getStatusCode() == 303
                    || he.getStatusCode() == 307) {
                throw new CmisConnectionException("Redirects are not supported (HTTP status code " + he.getStatusCode()
                        + "): " + message, he);
            } else {
                throw new CmisConnectionException(message, he);
            }
        } catch (InvocationTargetException ite) {
            String message = "Cannot initalize Web Services service object [" + service.getServiceName() + "]: "
                    + ite.getCause().getMessage();
            throw new CmisConnectionException(message, ite);
        } catch (Exception e) {
            String message = "Cannot initalize Web Services service object [" + service.getServiceName() + "]: "
                    + e.getMessage();
            throw new CmisConnectionException(message, e);
        }
    }

    /**
     * Reads the URL and extracts the endpoint URL of the given service.
     */
    private URL getEndpointUrlFromWsdl(final String wsdlUrl, final CmisWebSerivcesService service) {
        InputStream wsdlStream;
        URL url;

        // check the WSDL URL
        try {
            url = new URL(wsdlUrl);
        } catch (MalformedURLException e) {
            throw new CmisConnectionException("Invalid WSDL URL: " + wsdlUrl, e);
        }

        // check protocol
        if (url.getProtocol().equalsIgnoreCase("http") || url.getProtocol().equalsIgnoreCase("https")) {
            // HTTP URL -> use HttpInvoker to enable authentication
            HttpInvoker hi = CmisBindingsHelper.getHttpInvoker(session);
            Response wsdlResponse = hi.invokeGET(new UrlBuilder(wsdlUrl), session);

            if (wsdlResponse.getResponseCode() != 200) {
                throw new CmisConnectionException("Cannot access WSDL: " + wsdlUrl, BigInteger.ZERO,
                        wsdlResponse.getErrorContent());
            } else {
                wsdlStream = wsdlResponse.getStream();
            }
        } else {
            // non-HTTP URL -> just open the stream
            try {
                wsdlStream = url.openStream();
            } catch (IOException e) {
                throw new CmisConnectionException("Cannot access WSDL: " + wsdlUrl, e);
            }
        }

        // parse the WSDL
        try {
            final Document doc = XMLUtils.parseDomDocument(new BufferedInputStream(wsdlStream, 64 * 1024));

            NodeList serivceList = doc.getElementsByTagNameNS("http://schemas.xmlsoap.org/wsdl/", "service");
            for (int i = 0; i < serivceList.getLength(); i++) {
                Element serviceNode = (Element) serivceList.item(i);

                String name = serviceNode.getAttribute("name");
                if (name == null) {
                    continue;
                }

                if (!service.getQName().getLocalPart().equals(name)) {
                    continue;
                }

                NodeList portList = serviceNode.getElementsByTagNameNS("http://schemas.xmlsoap.org/wsdl/", "port");
                if (portList.getLength() < 1) {
                    throw new CmisRuntimeException("This service has no ports: " + service.getServiceName());
                }

                Element port = (Element) portList.item(0);

                NodeList addressList = port.getElementsByTagNameNS("http://schemas.xmlsoap.org/wsdl/soap/", "address");
                if (addressList.getLength() < 1) {
                    throw new CmisRuntimeException("This service has no endpoint address: " + service.getServiceName());
                }

                Element address = (Element) addressList.item(0);

                String location = address.getAttribute("location");
                if (location == null) {
                    throw new CmisRuntimeException("This service has no endpoint address: " + service.getServiceName());
                }

                try {
                    return new URL(location);
                } catch (MalformedURLException e) {
                    throw new CmisRuntimeException("This service provides an invalid endpoint address: "
                            + service.getServiceName(), e);
                }
            }

            throw new CmisRuntimeException("This service does not provide an endpoint address: "
                    + service.getServiceName());
        } catch (ParserConfigurationException pe) {
            throw new CmisRuntimeException("Cannot parse this WSDL: " + wsdlUrl, pe);
        } catch (SAXException se) {
            throw new CmisRuntimeException("Cannot parse this WSDL: " + wsdlUrl, se);
        } catch (IOException ioe) {
            throw new CmisRuntimeException("Cannot read this WSDL: " + wsdlUrl, ioe);
        } finally {
            IOUtils.closeQuietly(wsdlStream);
        }
    }

    /**
     * Sets the default HTTP headers on a {@link BindingProvider} object.
     */
    protected void setHTTPHeaders(BindingProvider portObject, Map<String, List<String>> httpHeaders) {
        if (httpHeaders == null) {
            httpHeaders = new HashMap<String, List<String>>();
        }

        // CMIS client header
        httpHeaders.put("X-CMIS-Client", Collections.singletonList(ClientVersion.OPENCMIS_CLIENT));

        // compression
        if (useCompression) {
            httpHeaders.put("Accept-Encoding", Collections.singletonList("gzip"));
        }

        // client compression
        if (useClientCompression) {
            httpHeaders.put("Content-Encoding", Collections.singletonList("gzip"));
        }

        // locale
        if (acceptLanguage != null) {
            httpHeaders.put("Accept-Language", Collections.singletonList(acceptLanguage));
        }

        portObject.getRequestContext().put(MessageContext.HTTP_REQUEST_HEADERS, httpHeaders);
    }

    /**
     * Sets the endpoint URL if the URL is not <code>null</code>.
     */
    protected void setEndpointUrl(BindingProvider portObject, URL endpointUrl) {
        if (endpointUrl == null) {
            return;
        }

        portObject.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, endpointUrl.toString());
    }

    /**
     * Sets the SOAP Action header.
     */
    protected void setSoapAction(BindingProvider portObject, String soapAction, CmisVersion cmisVersion) {
        portObject.getRequestContext().put(BindingProvider.SOAPACTION_USE_PROPERTY, Boolean.TRUE);

        if (cmisVersion == CmisVersion.CMIS_1_0) {
            portObject.getRequestContext().put(BindingProvider.SOAPACTION_URI_PROPERTY, "");
        } else {
            portObject.getRequestContext().put(BindingProvider.SOAPACTION_URI_PROPERTY, soapAction);
        }
    }

    /**
     * Creates a simple port object from a CmisServiceHolder object.
     */
    protected BindingProvider createPortObjectFromServiceHolder(final CmisServiceHolder serviceHolder,
            WebServiceFeature... features) throws Exception {
        portObjectLock.lock();
        try {
            ArrayDeque<SoftReference<BindingProvider>> queue = portObjectCache.get(serviceHolder.getService());
            if (queue == null) {
                queue = new ArrayDeque<SoftReference<BindingProvider>>();
                portObjectCache.put(serviceHolder.getService(), queue);
            }

            while (!queue.isEmpty()) {
                BindingProvider bp = queue.pop().get();
                if (bp != null) {
                    return bp;
                }
            }
        } finally {
            portObjectLock.unlock();
        }

        return (BindingProvider) serviceHolder.getServiceObject().getPort(serviceHolder.getService().getPortClass(),
                features);
    }

    /**
     * Creates a port object.
     */
    protected abstract BindingProvider createPortObject(CmisServiceHolder serviceHolder);
}