package org.apache.maven.wagon.shared.http;

 /*

  * 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.Credentials;

 import org.apache.commons.httpclient.Header;

 import org.apache.commons.httpclient.HostConfiguration;

 import org.apache.commons.httpclient.HttpClient;

 import org.apache.commons.httpclient.HttpConnectionManager;

 import org.apache.commons.httpclient.HttpMethod;

 import org.apache.commons.httpclient.HttpStatus;

 import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;

 import org.apache.commons.httpclient.NTCredentials;

 import org.apache.commons.httpclient.UsernamePasswordCredentials;

 import org.apache.commons.httpclient.auth.AuthScope;

 import org.apache.commons.httpclient.cookie.CookiePolicy;

 import org.apache.commons.httpclient.methods.GetMethod;

 import org.apache.commons.httpclient.methods.HeadMethod;

 import org.apache.commons.httpclient.methods.PutMethod;

 import org.apache.commons.httpclient.methods.RequestEntity;

 import org.apache.commons.httpclient.params.HttpMethodParams;

 import org.apache.commons.httpclient.util.DateParseException;

 import org.apache.commons.httpclient.util.DateUtil;

 import org.apache.maven.wagon.InputData;

 import org.apache.maven.wagon.OutputData;

 import org.apache.maven.wagon.PathUtils;

 import org.apache.maven.wagon.ResourceDoesNotExistException;

 import org.apache.maven.wagon.StreamWagon;

 import org.apache.maven.wagon.TransferFailedException;

 import org.apache.maven.wagon.Wagon;

 import org.apache.maven.wagon.authorization.AuthorizationException;

 import org.apache.maven.wagon.events.TransferEvent;

 import org.apache.maven.wagon.proxy.ProxyInfo;

 import org.apache.maven.wagon.repository.Repository;

 import org.apache.maven.wagon.resource.Resource;

 import org.codehaus.plexus.util.IOUtil;

 import org.codehaus.plexus.util.StringUtils;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileOutputStream;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.OutputStream;

 import java.net.URLEncoder;

 import java.text.SimpleDateFormat;

 import java.util.Date;

 import java.util.Iterator;

 import java.util.Locale;

 import java.util.Properties;

 import java.util.TimeZone;

 import java.util.zip.GZIPInputStream;

 /**

  * @author <a href="michal.maczka@dimatics.com">Michal Maczka</a>

  * @author <a href="mailto:james@atlassian.com">James William Dumay</a>

  */

 public abstract class AbstractHttpClientWagon

     extends StreamWagon

 {

     private final class RequestEntityImplementation

         implements RequestEntity

     {

         private final Resource resource;

         private final Wagon wagon;

         private final File source;

         private RequestEntityImplementation( final InputStream stream, final Resource resource, final Wagon wagon,

                                              final File source )

             throws TransferFailedException

         {

             if ( source != null )

             {

                 this.source = source;

             }

             else

             {

                 FileOutputStream fos = null;

                 try

                 {

                     this.source = File.createTempFile( "http-wagon.", ".tmp" );

                     this.source.deleteOnExit();

                     fos = new FileOutputStream( this.source );

                     IOUtil.copy( stream, fos );

                 }

                 catch ( IOException e )

                 {

                     fireTransferError( resource, e, TransferEvent.REQUEST_PUT );

                     throw new TransferFailedException( "Failed to buffer stream contents to temp file for upload.", e );

                 }

                 finally

                 {

                     IOUtil.close( fos );

                 }

             }

             this.resource = resource;

             this.wagon = wagon;

         }

         public long getContentLength()

         {

             return resource.getContentLength();

         }

         public String getContentType()

         {

             return null;

         }

         public boolean isRepeatable()

         {

             return true;

         }

         public void writeRequest( OutputStream output )

             throws IOException

         {

             byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];

             TransferEvent transferEvent =

                 new TransferEvent( wagon, resource, TransferEvent.TRANSFER_PROGRESS, TransferEvent.REQUEST_PUT );

             transferEvent.setTimestamp( System.currentTimeMillis() );

             FileInputStream fin = null;

             try

             {

                 fin = new FileInputStream( source );

                 int remaining = Integer.MAX_VALUE;

                 while ( remaining > 0 )

                 {

                     int n = fin.read( buffer, 0, Math.min( buffer.length, remaining ) );

                     if ( n == -1 )

                     {

                         break;

                     }

                     fireTransferProgress( transferEvent, buffer, n );

                     output.write( buffer, 0, n );

                     remaining -= n;

                 }

             }

             finally

             {

                 IOUtil.close( fin );

             }

             output.flush();

         }

     }

     protected static final int SC_NULL = -1;

     protected static final TimeZone GMT_TIME_ZONE = TimeZone.getTimeZone( "GMT" );

     private HttpClient client;

     protected HttpConnectionManager connectionManager = new MultiThreadedHttpConnectionManager();

     /**

      * @deprecated Use httpConfiguration instead.

      */

     private Properties httpHeaders;

     /**

      * @since 1.0-beta-6

      */

     private HttpConfiguration httpConfiguration;

     private HttpMethod getMethod;

     public void openConnectionInternal()

     {

         repository.setUrl( getURL( repository ) );

         client = new HttpClient( connectionManager );

         // WAGON-273: default the cookie-policy to browser compatible

         client.getParams().setCookiePolicy( CookiePolicy.BROWSER_COMPATIBILITY );

         String username = null;

         String password = null;

         if ( authenticationInfo != null )

         {

             username = authenticationInfo.getUserName();

             password = authenticationInfo.getPassword();

             client.getParams().setAuthenticationPreemptive( true );

         }

         String host = getRepository().getHost();

         if ( StringUtils.isNotEmpty( username ) && StringUtils.isNotEmpty( password ) )

         {

             Credentials creds = new UsernamePasswordCredentials( username, password );

             int port = getRepository().getPort() > -1 ? getRepository().getPort() : AuthScope.ANY_PORT;

             AuthScope scope = new AuthScope( host, port );

             client.getState().setCredentials( scope, creds );

         }

         HostConfiguration hc = new HostConfiguration();

         ProxyInfo proxyInfo = getProxyInfo( getRepository().getProtocol(), getRepository().getHost() );

         if ( proxyInfo != null )

         {

             String proxyUsername = proxyInfo.getUserName();

             String proxyPassword = proxyInfo.getPassword();

             String proxyHost = proxyInfo.getHost();

             int proxyPort = proxyInfo.getPort();

             String proxyNtlmHost = proxyInfo.getNtlmHost();

             String proxyNtlmDomain = proxyInfo.getNtlmDomain();

             if ( proxyHost != null )

             {

                 hc.setProxy( proxyHost, proxyPort );

                 if ( proxyUsername != null && proxyPassword != null )

                 {

                     Credentials creds;

                     if ( proxyNtlmHost != null || proxyNtlmDomain != null )

                     {

                         creds = new NTCredentials( proxyUsername, proxyPassword, proxyNtlmHost, proxyNtlmDomain );

                     }

                     else

                     {

                         creds = new UsernamePasswordCredentials( proxyUsername, proxyPassword );

                     }

                     int port = proxyInfo.getPort() > -1 ? proxyInfo.getPort() : AuthScope.ANY_PORT;

                     AuthScope scope = new AuthScope( proxyHost, port );

                     client.getState().setProxyCredentials( scope, creds );

                 }

             }

         }

         hc.setHost( host );

         //start a session with the webserver

         client.setHostConfiguration( hc );

     }

     public void closeConnection()

     {

         if ( connectionManager instanceof MultiThreadedHttpConnectionManager )

         {

             ( (MultiThreadedHttpConnectionManager) connectionManager ).shutdown();

         }

     }

     public void put( File source, String resourceName )

         throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException

     {

         Resource resource = new Resource( resourceName );

         firePutInitiated( resource, source );

         resource.setContentLength( source.length() );

         resource.setLastModified( source.lastModified() );

         put( null, resource, source );

     }

     public void putFromStream( final InputStream stream, String destination, long contentLength, long lastModified )

         throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException

     {

         Resource resource = new Resource( destination );

         firePutInitiated( resource, null );

         resource.setContentLength( contentLength );

         resource.setLastModified( lastModified );

         put( stream, resource, null );

     }

     private void put( final InputStream stream, Resource resource, File source )

         throws TransferFailedException, AuthorizationException, ResourceDoesNotExistException

     {

         StringBuilder url = new StringBuilder( getRepository().getUrl() );

         String[] parts = StringUtils.split( resource.getName(), "/" );

         for ( String part : parts )// int i = 0; i < parts.length; i++ )

         {

             // TODO: Fix encoding...

             // url += "/" + URLEncoder.encode( parts[i], System.getProperty("file.encoding") );

             if ( !url.toString().endsWith( "/" ) )

             {

                 url.append( '/' );

             }

             url.append( URLEncoder.encode( part ) );

         }

         //Parent directories need to be created before posting

         try

         {

             mkdirs( PathUtils.dirname( resource.getName() ) );

         }

         catch ( IOException e )

         {

             fireTransferError( resource, e, TransferEvent.REQUEST_GET );

         }

         PutMethod putMethod = new PutMethod( url.toString() );

         firePutStarted( resource, source );

         try

         {

             putMethod.setRequestEntity( new RequestEntityImplementation( stream, resource, this, source ) );

             int statusCode;

             try

             {

                 statusCode = execute( putMethod );

             }

             catch ( IOException e )

             {

                 fireTransferError( resource, e, TransferEvent.REQUEST_PUT );

                 throw new TransferFailedException( e.getMessage(), e );

             }

             fireTransferDebug( url + " - Status code: " + statusCode );

             // Check that we didn't run out of retries.

             switch ( statusCode )

             {

                 // Success Codes

                 case HttpStatus.SC_OK: // 200

                 case HttpStatus.SC_CREATED: // 201

                 case HttpStatus.SC_ACCEPTED: // 202

                 case HttpStatus.SC_NO_CONTENT:  // 204

                     break;

                 case SC_NULL:

                 {

                     TransferFailedException e = new TransferFailedException( "Failed to transfer file: " + url );

                     fireTransferError( resource, e, TransferEvent.REQUEST_PUT );

                     throw e;

                 }

                 case HttpStatus.SC_FORBIDDEN:

                     fireSessionConnectionRefused();

                     throw new AuthorizationException( "Access denied to: " + url );

                 case HttpStatus.SC_NOT_FOUND:

                     throw new ResourceDoesNotExistException( "File: " + url + " does not exist" );

                     //add more entries here

                 default:

                 {

                     TransferFailedException e = new TransferFailedException(

                         "Failed to transfer file: " + url + ". Return code is: " + statusCode );

                     fireTransferError( resource, e, TransferEvent.REQUEST_PUT );

                     throw e;

                 }

             }

             firePutCompleted( resource, source );

         }

         finally

         {

             putMethod.releaseConnection();

         }

     }

     protected void mkdirs( String dirname )

         throws IOException

     {

         // do nothing as default.

     }

     public boolean resourceExists( String resourceName )

         throws TransferFailedException, AuthorizationException

     {

         StringBuilder url = new StringBuilder( getRepository().getUrl() );

         if ( !url.toString().endsWith( "/" ) )

         {

             url.append( '/' );

         }

         url.append( resourceName );

         HeadMethod headMethod = new HeadMethod( url.toString() );

         int statusCode;

         try

         {

             statusCode = execute( headMethod );

         }

         catch ( IOException e )

         {

             throw new TransferFailedException( e.getMessage(), e );

         }

         try

         {

             switch ( statusCode )

             {

                 case HttpStatus.SC_OK:

                     return true;

                 case HttpStatus.SC_NOT_MODIFIED:

                     return true;

                 case SC_NULL:

                     throw new TransferFailedException( "Failed to transfer file: " + url );

                 case HttpStatus.SC_FORBIDDEN:

                     throw new AuthorizationException( "Access denied to: " + url );

                 case HttpStatus.SC_UNAUTHORIZED:

                     throw new AuthorizationException( "Not authorized." );

                 case HttpStatus.SC_PROXY_AUTHENTICATION_REQUIRED:

                     throw new AuthorizationException( "Not authorized by proxy." );

                 case HttpStatus.SC_NOT_FOUND:

                     return false;

                 //add more entries here

                 default:

                     throw new TransferFailedException(

                         "Failed to transfer file: " + url + ". Return code is: " + statusCode );

             }

         }

         finally

         {

             headMethod.releaseConnection();

         }

     }

     protected int execute( HttpMethod httpMethod )

         throws IOException

     {

         int statusCode;

         setParameters( httpMethod );

         setHeaders( httpMethod );

         statusCode = client.executeMethod( httpMethod );

         return statusCode;

     }

     protected void setParameters( HttpMethod method )

     {

         HttpMethodConfiguration config =

             httpConfiguration == null ? null : httpConfiguration.getMethodConfiguration( method );

         if ( config != null )

         {

             HttpMethodParams params = config.asMethodParams( method.getParams() );

             if ( params != null )

             {

                 method.setParams( params );

             }

         }

         if ( config == null || config.getConnectionTimeout() == HttpMethodConfiguration.DEFAULT_CONNECTION_TIMEOUT )

         {

             method.getParams().setSoTimeout( getTimeout() );

         }

     }

     protected void setHeaders( HttpMethod method )

     {

         HttpMethodConfiguration config =

             httpConfiguration == null ? null : httpConfiguration.getMethodConfiguration( method );

         if ( config == null || config.isUseDefaultHeaders() )

         {

             // TODO: merge with the other headers and have some better defaults, unify with lightweight headers

             method.addRequestHeader( "Cache-control", "no-cache" );

             method.addRequestHeader( "Cache-store", "no-store" );

             method.addRequestHeader( "Pragma", "no-cache" );

             method.addRequestHeader( "Expires", "0" );

             method.addRequestHeader( "Accept-Encoding", "gzip" );

         }

         if ( httpHeaders != null )

         {

             for ( Iterator i = httpHeaders.keySet().iterator(); i.hasNext(); )

             {

                 String header = (String) i.next();

                 method.addRequestHeader( header, httpHeaders.getProperty( header ) );

             }

         }

         Header[] headers = config == null ? null : config.asRequestHeaders();

         if ( headers != null )

         {

             for ( int i = 0; i < headers.length; i++ )

             {

                 method.addRequestHeader( headers[i] );

             }

         }

     }

     /**

      * getUrl

      * Implementors can override this to remove unwanted parts of the url such as role-hints

      *

      * @param repository

      * @return

      */

     protected String getURL( Repository repository )

     {

         return repository.getUrl();

     }

     protected HttpClient getClient()

     {

         return client;

     }

     public void setConnectionManager( HttpConnectionManager connectionManager )

     {

         this.connectionManager = connectionManager;

     }

     public Properties getHttpHeaders()

     {

         return httpHeaders;

     }

     public void setHttpHeaders( Properties httpHeaders )

     {

         this.httpHeaders = httpHeaders;

     }

     public HttpConfiguration getHttpConfiguration()

     {

         return httpConfiguration;

     }

     public void setHttpConfiguration( HttpConfiguration httpConfiguration )

     {

         this.httpConfiguration = httpConfiguration;

     }

     public void fillInputData( InputData inputData )

         throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException

     {

         Resource resource = inputData.getResource();

         StringBuilder url = new StringBuilder( getRepository().getUrl() );

         if ( !url.toString().endsWith( "/" ) )

         {

             url.append( '/' );

         }

         url.append( resource.getName() );

         getMethod = new GetMethod( url.toString() );

         long timestamp = resource.getLastModified();

         if ( timestamp > 0 )

         {

             SimpleDateFormat fmt = new SimpleDateFormat( "EEE, dd-MMM-yy HH:mm:ss zzz", Locale.US );

             fmt.setTimeZone( GMT_TIME_ZONE );

             Header hdr = new Header( "If-Modified-Since", fmt.format( new Date( timestamp ) ) );

             fireTransferDebug( "sending ==> " + hdr + "(" + timestamp + ")" );

             getMethod.addRequestHeader( hdr );

         }

         int statusCode;

         try

         {

             statusCode = execute( getMethod );

         }

         catch ( IOException e )

         {

             fireTransferError( resource, e, TransferEvent.REQUEST_GET );

             throw new TransferFailedException( e.getMessage(), e );

         }

         fireTransferDebug( url + " - Status code: " + statusCode );

         // TODO [BP]: according to httpclient docs, really should swallow the output on error. verify if that is

         // required

         switch ( statusCode )

         {

             case HttpStatus.SC_OK:

                 break;

             case HttpStatus.SC_NOT_MODIFIED:

                 // return, leaving last modified set to original value so getIfNewer should return unmodified

                 return;

             case SC_NULL:

             {

                 TransferFailedException e = new TransferFailedException( "Failed to transfer file: " + url );

                 fireTransferError( resource, e, TransferEvent.REQUEST_GET );

                 throw e;

             }

             case HttpStatus.SC_FORBIDDEN:

                 fireSessionConnectionRefused();

                 throw new AuthorizationException( "Access denied to: " + url );

             case HttpStatus.SC_UNAUTHORIZED:

                 fireSessionConnectionRefused();

                 throw new AuthorizationException( "Not authorized." );

             case HttpStatus.SC_PROXY_AUTHENTICATION_REQUIRED:

                 fireSessionConnectionRefused();

                 throw new AuthorizationException( "Not authorized by proxy." );

             case HttpStatus.SC_NOT_FOUND:

                 throw new ResourceDoesNotExistException( "File: " + url + " does not exist" );

                 // add more entries here

             default:

             {

                 cleanupGetTransfer( resource );

                 TransferFailedException e = new TransferFailedException(

                     "Failed to transfer file: " + url + ". Return code is: " + statusCode );

                 fireTransferError( resource, e, TransferEvent.REQUEST_GET );

                 throw e;

             }

         }

         InputStream is = null;

         Header contentLengthHeader = getMethod.getResponseHeader( "Content-Length" );

         if ( contentLengthHeader != null )

         {

             try

             {

                 long contentLength = Integer.valueOf( contentLengthHeader.getValue() ).intValue();

                 resource.setContentLength( contentLength );

             }

             catch ( NumberFormatException e )

             {

                 fireTransferDebug(

                     "error parsing content length header '" + contentLengthHeader.getValue() + "' " + e );

             }

         }

         Header lastModifiedHeader = getMethod.getResponseHeader( "Last-Modified" );

         long lastModified = 0;

         if ( lastModifiedHeader != null )

         {

             try

             {

                 lastModified = DateUtil.parseDate( lastModifiedHeader.getValue() ).getTime();

                 resource.setLastModified( lastModified );

             }

             catch ( DateParseException e )

             {

                 fireTransferDebug( "Unable to parse last modified header" );

             }

             fireTransferDebug( "last-modified = " + lastModifiedHeader.getValue() + " (" + lastModified + ")" );

         }

         Header contentEncoding = getMethod.getResponseHeader( "Content-Encoding" );

         boolean isGZipped = contentEncoding != null && "gzip".equalsIgnoreCase( contentEncoding.getValue() );

         try

         {

             is = getMethod.getResponseBodyAsStream();

             if ( isGZipped )

             {

                 is = new GZIPInputStream( is );

             }

         }

         catch ( IOException e )

         {

             fireTransferError( resource, e, TransferEvent.REQUEST_GET );

             String msg =

                 "Error occurred while retrieving from remote repository:" + getRepository() + ": " + e.getMessage();

             throw new TransferFailedException( msg, e );

         }

         inputData.setInputStream( is );

     }

     protected void cleanupGetTransfer( Resource resource )

     {

         if ( getMethod != null )

         {

             getMethod.releaseConnection();

         }

     }

     @Override

     public void putFromStream( InputStream stream, String destination )

         throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException

     {

         putFromStream( stream, destination, -1, -1 );

     }

     @Override

     protected void putFromStream( InputStream stream, Resource resource )

         throws TransferFailedException, AuthorizationException, ResourceDoesNotExistException

     {

         putFromStream( stream, resource.getName( ), -1, -1 );

     }

     @Override

     public void fillOutputData( OutputData outputData )

         throws TransferFailedException

     {

         // no needed in this implementation but throw an Exception if used

         throw new IllegalStateException( "this wagon http client must not use fillOutputData" );

     }

 }