/*

  * Copyright 2004-2007 the original author or authors.

  *

  * 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.kuali.maven.wagon;

 import java.io.File;

 import java.util.List;

 import org.apache.maven.wagon.ConnectionException;

 import org.apache.maven.wagon.ResourceDoesNotExistException;

 import org.apache.maven.wagon.TransferFailedException;

 import org.apache.maven.wagon.Wagon;

 import org.apache.maven.wagon.authentication.AuthenticationException;

 import org.apache.maven.wagon.authentication.AuthenticationInfo;

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

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

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

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

 import org.apache.maven.wagon.observers.Debug;

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

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

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

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

 /**

  * An abstract implementation of the Wagon interface. This implementation manages listener and other common behaviors.

  *

  * @author Ben Hale

  * @author Jeff Caddel - Updates for version 1.0-beta-6 of the Wagon interface

  * @since 1.1

  */

 public abstract class AbstractWagon implements Wagon {

     private int timeout;

     private boolean interactive;

     private Repository repository;

     private final boolean supportsDirectoryCopy;

     private final SessionListenerSupport sessionListeners = new SessionListenerSupport(this);

     private final TransferListenerSupport transferListeners = new TransferListenerSupport(this);

     protected AbstractWagon(final boolean supportsDirectoryCopy) {

         this.supportsDirectoryCopy = supportsDirectoryCopy;

     }

     public final void addSessionListener(final SessionListener listener) {

         if (listener.getClass().equals(Debug.class)) {

             // This is a junky listener that spews things to System.out in an ugly way

             return;

         }

         sessionListeners.addListener(listener);

     }

     protected final SessionListenerSupport getSessionListeners() {

         return sessionListeners;

     }

     public final boolean hasSessionListener(final SessionListener listener) {

         return sessionListeners.hasListener(listener);

     }

     public final void removeSessionListener(final SessionListener listener) {

         sessionListeners.removeListener(listener);

     }

     public final void addTransferListener(final TransferListener listener) {

         transferListeners.addListener(listener);

     }

     protected final TransferListenerSupport getTransferListeners() {

         return transferListeners;

     }

     public final boolean hasTransferListener(final TransferListener listener) {

         return transferListeners.hasListener(listener);

     }

     public final void removeTransferListener(final TransferListener listener) {

         transferListeners.removeListener(listener);

     }

     public final Repository getRepository() {

         return repository;

     }

     public final boolean isInteractive() {

         return interactive;

     }

     public final void setInteractive(final boolean interactive) {

         this.interactive = interactive;

     }

     public final void connect(final Repository source) throws ConnectionException, AuthenticationException {

         doConnect(source, null, null);

     }

     public final void connect(final Repository source, final ProxyInfo proxyInfo) throws ConnectionException,

             AuthenticationException {

         connect(source, null, proxyInfo);

     }

     public final void connect(final Repository source, final AuthenticationInfo authenticationInfo)

             throws ConnectionException, AuthenticationException {

         doConnect(source, authenticationInfo, null);

     }

     protected void doConnect(final Repository source, final AuthenticationInfo authenticationInfo,

             final ProxyInfo proxyInfo) throws ConnectionException, AuthenticationException {

         repository = source;

         sessionListeners.fireSessionOpening();

         try {

             connectToRepository(source, authenticationInfo, proxyInfo);

         } catch (ConnectionException e) {

             sessionListeners.fireSessionConnectionRefused();

             throw e;

         } catch (AuthenticationException e) {

             sessionListeners.fireSessionConnectionRefused();

             throw e;

         } catch (Exception e) {

             sessionListeners.fireSessionConnectionRefused();

             throw new ConnectionException("Could not connect to repository", e);

         }

         sessionListeners.fireSessionLoggedIn();

         sessionListeners.fireSessionOpened();

     }

     public final void connect(final Repository source, final AuthenticationInfo authenticationInfo,

             final ProxyInfo proxyInfo) throws ConnectionException, AuthenticationException {

         doConnect(source, authenticationInfo, proxyInfo);

     }

     public final void disconnect() throws ConnectionException {

         sessionListeners.fireSessionDisconnecting();

         try {

             disconnectFromRepository();

         } catch (ConnectionException e) {

             sessionListeners.fireSessionConnectionRefused();

             throw e;

         } catch (Exception e) {

             sessionListeners.fireSessionConnectionRefused();

             throw new ConnectionException("Could not disconnect from repository", e);

         }

         sessionListeners.fireSessionLoggedOff();

         sessionListeners.fireSessionDisconnected();

     }

     public final void get(final String resourceName, final File destination) throws TransferFailedException,

             ResourceDoesNotExistException, AuthorizationException {

         Resource resource = new Resource(resourceName);

         transferListeners.fireTransferInitiated(resource, TransferEvent.REQUEST_GET);

         transferListeners.fireTransferStarted(resource, TransferEvent.REQUEST_GET);

         try {

             getResource(resourceName, destination, new TransferProgress(resource, TransferEvent.REQUEST_GET,

                     transferListeners));

             transferListeners.fireTransferCompleted(resource, TransferEvent.REQUEST_GET);

         } catch (TransferFailedException e) {

             throw e;

         } catch (ResourceDoesNotExistException e) {

             throw e;

         } catch (AuthorizationException e) {

             throw e;

         } catch (Exception e) {

             transferListeners.fireTransferError(resource, TransferEvent.REQUEST_GET, e);

             throw new TransferFailedException("Transfer of resource " + destination + "failed", e);

         }

     }

     @SuppressWarnings("rawtypes")

     public final List getFileList(final String destinationDirectory) throws TransferFailedException,

             ResourceDoesNotExistException, AuthorizationException {

         try {

             return listDirectory(destinationDirectory);

         } catch (TransferFailedException e) {

             throw e;

         } catch (ResourceDoesNotExistException e) {

             throw e;

         } catch (AuthorizationException e) {

             throw e;

         } catch (Exception e) {

             sessionListeners.fireSessionError(e);

             throw new TransferFailedException("Listing of directory " + destinationDirectory + "failed", e);

         }

     }

     public final boolean getIfNewer(final String resourceName, final File destination, final long timestamp)

             throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException {

         Resource resource = new Resource(resourceName);

         try {

             if (isRemoteResourceNewer(resourceName, timestamp)) {

                 get(resourceName, destination);

                 return true;

             } else {

                 return false;

             }

         } catch (TransferFailedException e) {

             throw e;

         } catch (ResourceDoesNotExistException e) {

             throw e;

         } catch (AuthorizationException e) {

             throw e;

         } catch (Exception e) {

             transferListeners.fireTransferError(resource, TransferEvent.REQUEST_GET, e);

             throw new TransferFailedException("Transfer of resource " + destination + "failed", e);

         }

     }

     public final void openConnection() throws ConnectionException, AuthenticationException {

         // Nothing to do here (never called by the wagon manager)

     }

     public final void put(final File source, final String destination) throws TransferFailedException,

             ResourceDoesNotExistException, AuthorizationException {

         Resource resource = new Resource(destination);

         transferListeners.fireTransferInitiated(resource, TransferEvent.REQUEST_PUT);

         transferListeners.fireTransferStarted(resource, TransferEvent.REQUEST_PUT);

         try {

             putResource(source, destination, new TransferProgress(resource, TransferEvent.REQUEST_PUT,

                     transferListeners));

             transferListeners.fireTransferCompleted(resource, TransferEvent.REQUEST_PUT);

         } catch (TransferFailedException e) {

             throw e;

         } catch (ResourceDoesNotExistException e) {

             throw e;

         } catch (AuthorizationException e) {

             throw e;

         } catch (Exception e) {

             transferListeners.fireTransferError(resource, TransferEvent.REQUEST_PUT, e);

             throw new TransferFailedException("Transfer of resource " + destination + "failed", e);

         }

     }

     /**

      * On S3 there are no true "directories". An S3 bucket is essentially a Hashtable of files stored by key. The

      * integration between a traditional file system and an S3 bucket is to use the path of the file on the local file

      * system as the key to the file in the bucket. The S3 bucket does not contain a separate key for the directory

      * itself.

      */

     public final void putDirectory(final File sourceDirectory, final String destinationDirectory)

             throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException {

         // Cycle through all the files in this directory

         for (File f : sourceDirectory.listFiles()) {

             // We hit a directory

             if (f.isDirectory()) {

                 // Recurse into the sub-directory and store any files we find

                 putDirectory(f, destinationDirectory + "/" + f.getName());

             } else {

                 // Normal file, store it into S3

                 put(f, destinationDirectory + "/" + f.getName());

             }

         }

     }

     public final boolean resourceExists(final String resourceName) throws TransferFailedException,

             AuthorizationException {

         try {

             return doesRemoteResourceExist(resourceName);

         } catch (TransferFailedException e) {

             throw e;

         } catch (AuthorizationException e) {

             throw e;

         } catch (Exception e) {

             sessionListeners.fireSessionError(e);

             throw new TransferFailedException("Listing of resource " + resourceName + "failed", e);

         }

     }

     public final boolean supportsDirectoryCopy() {

         return supportsDirectoryCopy;

     }

     /**

      * Subclass must implement with specific connection behavior

      *

      * @param source

      * The repository connection information

      * @param authenticationInfo

      * Authentication information, if any

      * @param proxyInfo

      * Proxy information, if any

      * @throws Exception

      * Implementations can throw any exception and it will be handled by the base class

      */

     protected abstract void connectToRepository(Repository source, AuthenticationInfo authenticationInfo,

             ProxyInfo proxyInfo) throws Exception;

     /**

      * Subclass must implement with specific detection behavior

      *

      * @param resourceName

      * The remote resource to detect

      * @return true if the remote resource exists

      * @throws Exception

      * Implementations can throw any exception and it will be handled by the base class

      */

     protected abstract boolean doesRemoteResourceExist(String resourceName) throws Exception;

     /**

      * Subclasses must implement with specific disconnection behavior

      *

      * @throws Exception

      * Implementations can throw any exception and it will be handled by the base class

      */

     protected abstract void disconnectFromRepository() throws Exception;

     /**

      * Subclass must implement with specific get behavior

      *

      * @param resourceName

      * The name of the remote resource to read

      * @param destination

      * The local file to write to

      * @param progress

      * A progress notifier for the upload. It must be used or hashes will not be calculated correctly

      * @throws Exception

      * Implementations can throw any exception and it will be handled by the base class

      */

     protected abstract void getResource(String resourceName, File destination, TransferProgress progress)

             throws Exception;

     /**

      * Subclass must implement with newer detection behavior

      *

      * @param resourceName

      * The name of the resource being compared

      * @param timestamp

      * The timestamp to compare against

      * @return true if the current version of the resource is newer than the timestamp

      * @throws Exception

      * Implementations can throw any exception and it will be handled by the base class

      */

     protected abstract boolean isRemoteResourceNewer(String resourceName, long timestamp) throws Exception;

     /**

      * Subclass must implement with specific directory listing behavior

      *

      * @param directory

      * The directory to list files in

      * @return A collection of file names

      * @throws Exception

      * Implementations can throw any exception and it will be handled by the base class

      */

     protected abstract List<String> listDirectory(String directory) throws Exception;

     /**

      * Subclasses must implement with specific put behavior

      *

      * @param source

      * The local source file to read from

      * @param destination

      * The name of the remote resource to write to

      * @param progress

      * A progress notifier for the upload. It must be used or hashes will not be calculated correctly

      * @throws Exception

      * Implementations can throw any exception and it will be handled by the base class

      */

     protected abstract void putResource(File source, String destination, TransferProgress progress) throws Exception;

     public void connect(final Repository source, final AuthenticationInfo authenticationInfo,

             final ProxyInfoProvider proxyInfoProvider) throws ConnectionException, AuthenticationException {

         doConnect(source, authenticationInfo, null);

     }

     public void connect(final Repository source, final ProxyInfoProvider proxyInfoProvider) throws ConnectionException,

             AuthenticationException {

         doConnect(source, null, null);

     }

     public int getTimeout() {

         return this.timeout;

     }

     public void setTimeout(final int timeoutValue) {

         this.timeout = timeoutValue;

     }

 }