package org.apache.commons.jcs.auxiliary.remote.http.client;

import java.io.IOException;

/*
 * 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.
 */

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.HttpState;
import org.apache.commons.httpclient.HttpVersion;
import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;
import org.apache.commons.httpclient.cookie.CookiePolicy;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * This class simply configures the http multithreaded connection manager.
 * <p>
 * This is abstract because it can do anything. Child classes can overwrite whatever they want.
 */
public abstract class AbstractHttpClient
{
    /** The connection manager. */
    private MultiThreadedHttpConnectionManager connectionManager;

    /** The client */
    private HttpClient httpClient;

    /** Configuration settings. */
    private RemoteHttpCacheAttributes remoteHttpCacheAttributes;

    /** The Logger. */
    private static final Log log = LogFactory.getLog( AbstractHttpClient.class );

    /**
     * Sets the default Properties File and Heading, and creates the HttpClient and connection
     * manager.
     * <p>
     * @param remoteHttpCacheAttributes
     */
    public AbstractHttpClient( RemoteHttpCacheAttributes remoteHttpCacheAttributes )
    {
        this.remoteHttpCacheAttributes = remoteHttpCacheAttributes;
        this.connectionManager = new MultiThreadedHttpConnectionManager();
        this.httpClient = new HttpClient(this.connectionManager);

        configureClient();
    }

    /**
     * Configures the http client.
     */
    protected void configureClient()
    {
        if ( getRemoteHttpCacheAttributes().getMaxConnectionsPerHost() > 0 )
        {
            this.connectionManager.getParams()
                .setMaxTotalConnections(getRemoteHttpCacheAttributes().getMaxConnectionsPerHost());
            this.connectionManager.getParams()
                .setDefaultMaxConnectionsPerHost(getRemoteHttpCacheAttributes().getMaxConnectionsPerHost());
        }

        this.connectionManager.getParams().setSoTimeout( getRemoteHttpCacheAttributes().getSocketTimeoutMillis() );

        String httpVersion = getRemoteHttpCacheAttributes().getHttpVersion();
        if ( httpVersion != null )
        {
            if ( "1.1".equals( httpVersion ) )
            {
                this.httpClient.getParams().setParameter( "http.protocol.version", HttpVersion.HTTP_1_1 );
            }
            else if ( "1.0".equals( httpVersion ) )
            {
                this.httpClient.getParams().setParameter( "http.protocol.version", HttpVersion.HTTP_1_0 );
            }
            else
            {
                log.warn( "Unrecognized value for 'httpVersion': [" + httpVersion + "]" );
            }
        }

        this.connectionManager.getParams()
            .setConnectionTimeout(getRemoteHttpCacheAttributes().getConnectionTimeoutMillis());

        // By default we instruct HttpClient to ignore cookies.
        this.httpClient.getParams().setCookiePolicy( CookiePolicy.IGNORE_COOKIES );
    }

    /**
     * Extracted method that can be overwritten to do additional things to the post before the call
     * is made.
     * <p>
     * @param post the post that is about to get executed.
     * @throws IOException on i/o error
     */
    protected final void doWebserviceCall( HttpMethod post )
        throws IOException
    {
        HttpState httpState = preProcessWebserviceCall( post );
        this.httpClient.executeMethod( null, post, httpState );
        postProcessWebserviceCall( post, httpState );
    }

    /**
     * Called before the executeMethod on the client.
     * <p>
     * @param post http method
     * @return HttpState
     * @throws IOException
     */
    protected abstract HttpState preProcessWebserviceCall( HttpMethod post )
        throws IOException;

    /**
     * Called after the executeMethod on the client.
     * <p>
     * @param post http method
     * @param httpState state
     * @throws IOException
     */
    protected abstract void postProcessWebserviceCall( HttpMethod post, HttpState httpState )
        throws IOException;

    /**
     * @return the remoteHttpCacheAttributes
     */
    protected RemoteHttpCacheAttributes getRemoteHttpCacheAttributes()
    {
        return remoteHttpCacheAttributes;
    }
}