package org.apache.archiva.web.xmlrpc.services;

 /*

  * 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 java.util.ArrayList;

 import java.util.Collection;

 import java.util.List;

 import org.apache.archiva.web.xmlrpc.api.AdministrationService;

 import org.apache.archiva.web.xmlrpc.api.beans.ManagedRepository;

 import org.apache.archiva.web.xmlrpc.api.beans.RemoteRepository;

 import org.apache.maven.archiva.configuration.ArchivaConfiguration;

 import org.apache.maven.archiva.configuration.Configuration;

 import org.apache.maven.archiva.configuration.DatabaseScanningConfiguration;

 import org.apache.maven.archiva.configuration.IndeterminateConfigurationException;

 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;

 import org.apache.maven.archiva.configuration.RemoteRepositoryConfiguration;

 import org.apache.maven.archiva.configuration.RepositoryScanningConfiguration;

 import org.apache.maven.archiva.consumers.InvalidRepositoryContentConsumer;

 import org.apache.maven.archiva.consumers.KnownRepositoryContentConsumer;

 import org.apache.maven.archiva.database.ArchivaDatabaseException;

 import org.apache.maven.archiva.database.ArtifactDAO;

 import org.apache.maven.archiva.database.constraints.ArtifactVersionsConstraint;

 import org.apache.maven.archiva.database.updater.DatabaseCleanupConsumer;

 import org.apache.maven.archiva.database.updater.DatabaseConsumers;

 import org.apache.maven.archiva.database.updater.DatabaseUnprocessedArtifactConsumer;

 import org.apache.maven.archiva.model.ArchivaArtifact;

 import org.apache.maven.archiva.model.VersionedReference;

 import org.apache.maven.archiva.repository.ContentNotFoundException;

 import org.apache.maven.archiva.repository.ManagedRepositoryContent;

 import org.apache.maven.archiva.repository.RepositoryContentFactory;

 import org.apache.maven.archiva.repository.RepositoryException;

 import org.apache.maven.archiva.repository.RepositoryNotFoundException;

 import org.apache.maven.archiva.repository.events.RepositoryListener;

 import org.apache.maven.archiva.repository.scanner.RepositoryContentConsumers;

 import org.apache.maven.archiva.scheduled.ArchivaTaskScheduler;

 import org.apache.maven.archiva.scheduled.tasks.DatabaseTask;

 import org.apache.maven.archiva.scheduled.tasks.RepositoryTask;

 import org.apache.maven.archiva.scheduled.tasks.TaskCreator;

 import org.codehaus.plexus.registry.RegistryException;

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 /**

  * AdministrationServiceImpl

  * 

  * @version $Id: AdministrationServiceImpl.java

  */

 public class AdministrationServiceImpl

     implements AdministrationService

 {    

     protected Logger log = LoggerFactory.getLogger( getClass() );

     private ArchivaConfiguration archivaConfiguration;

     private RepositoryContentConsumers repoConsumersUtil;

     private DatabaseConsumers dbConsumersUtil;

     private RepositoryContentFactory repoFactory;

     private ArtifactDAO artifactDAO;

     private ArchivaTaskScheduler taskScheduler;

     private Collection<RepositoryListener> listeners;

     public AdministrationServiceImpl( ArchivaConfiguration archivaConfig, RepositoryContentConsumers repoConsumersUtil,

                                       DatabaseConsumers dbConsumersUtil, RepositoryContentFactory repoFactory,

                                       ArtifactDAO artifactDAO, ArchivaTaskScheduler taskScheduler,

                                       Collection<RepositoryListener> listeners )

     {

         this.archivaConfiguration = archivaConfig;

         this.repoConsumersUtil = repoConsumersUtil;

         this.dbConsumersUtil = dbConsumersUtil;

         this.repoFactory = repoFactory;

         this.artifactDAO = artifactDAO;

         this.taskScheduler = taskScheduler;

         this.listeners = listeners;

     }

     /**

      * @see AdministrationService#configureDatabaseConsumer(String, boolean)

      */

     public Boolean configureDatabaseConsumer( String consumerId, boolean enable ) throws Exception

     {

         List<DatabaseCleanupConsumer> cleanupConsumers = dbConsumersUtil.getAvailableCleanupConsumers();

         List<DatabaseUnprocessedArtifactConsumer> unprocessedConsumers =

             dbConsumersUtil.getAvailableUnprocessedConsumers();

         boolean found = false;

         boolean isCleanupConsumer = false;        

         for( DatabaseCleanupConsumer consumer : cleanupConsumers )

         {

             if( consumer.getId().equals( consumerId ) )

             {

                 found = true;

                 isCleanupConsumer = true;

                 break;

             }

         }

         if( !found )

         {

             for( DatabaseUnprocessedArtifactConsumer consumer : unprocessedConsumers )

             {

                 if( consumer.getId().equals( consumerId ) )

                 {

                     found = true;

                     break;

                 }

             }

         }

         if( !found )

         {

             throw new Exception( "Invalid database consumer." );

         }

         Configuration config = archivaConfiguration.getConfiguration();

         DatabaseScanningConfiguration dbScanningConfig = config.getDatabaseScanning();

         if( isCleanupConsumer )

         {

             dbScanningConfig.addCleanupConsumer( consumerId );            

         }

         else

         {

             dbScanningConfig.addUnprocessedConsumer( consumerId );

         }

         config.setDatabaseScanning( dbScanningConfig );        

         saveConfiguration( config );

         return new Boolean( true );

     }

     /**

      * @see AdministrationService#configureRepositoryConsumer(String, String, boolean)

      */

     public Boolean configureRepositoryConsumer( String repoId, String consumerId, boolean enable )

         throws Exception

     {

         // TODO use repoId once consumers are configured per repository! (MRM-930)

         List<KnownRepositoryContentConsumer> knownConsumers = repoConsumersUtil.getAvailableKnownConsumers();

         List<InvalidRepositoryContentConsumer> invalidConsumers = repoConsumersUtil.getAvailableInvalidConsumers();

         boolean found = false;

         boolean isKnownContentConsumer = false;

         for( KnownRepositoryContentConsumer consumer : knownConsumers )

         {

             if( consumer.getId().equals( consumerId ) )

             {

                 found = true;

                 isKnownContentConsumer = true;

                 break;

             }

         }

         if( !found )

         {

             for( InvalidRepositoryContentConsumer consumer : invalidConsumers )

             {

                 if( consumer.getId().equals( consumerId ) )

                 {

                     found = true;

                     break;

                 }

             }

         }

         if( !found )

         {

             throw new Exception( "Invalid repository consumer." );

         }

         Configuration config = archivaConfiguration.getConfiguration();

         RepositoryScanningConfiguration repoScanningConfig = config.getRepositoryScanning();

         if( isKnownContentConsumer )

         {

             repoScanningConfig.addKnownContentConsumer( consumerId );

         }

         else

         {

             repoScanningConfig.addInvalidContentConsumer( consumerId );

         }

         config.setRepositoryScanning( repoScanningConfig );        

         saveConfiguration( config );

         return new Boolean( true );

     }

     /**

      * @see AdministrationService#deleteArtifact(String, String, String, String)

      */

     public Boolean deleteArtifact( String repoId, String groupId, String artifactId, String version )

         throws Exception

     {

         Configuration config = archivaConfiguration.getConfiguration();

         ManagedRepositoryConfiguration repoConfig = config.findManagedRepositoryById( repoId );

         if( repoConfig == null )

         {

             throw new Exception( "Repository does not exist." );

         }

         try

         {

             ManagedRepositoryContent repoContent = repoFactory.getManagedRepositoryContent( repoId );            

             VersionedReference ref = new VersionedReference();

             ref.setGroupId( groupId );

             ref.setArtifactId( artifactId );

             ref.setVersion( version );

             // delete from file system

             repoContent.deleteVersion( ref );

             ArtifactVersionsConstraint constraint = new ArtifactVersionsConstraint( repoId, groupId, artifactId, false );

             List<ArchivaArtifact> artifacts = null;

             try

             {

                 artifacts = artifactDAO.queryArtifacts( constraint );

             }

             catch ( ArchivaDatabaseException e )

             {

                 throw new Exception( "Error occurred while cleaning up database." );

             }            

             if ( artifacts != null )

             {

                 for ( ArchivaArtifact artifact : artifacts )

                 {

                     if ( artifact.getVersion().equals( version ) )

                     {

                         for ( RepositoryListener listener : listeners )

                         {

                             listener.deleteArtifact( repoContent, artifact );

                         }

                     }

                 }

             }

         }

         catch ( ContentNotFoundException e )

         {

             throw new Exception( "Artifact does not exist." );

         }

         catch ( RepositoryNotFoundException e )

         {

             throw new Exception( "Repository does not exist." );

         }

         catch ( RepositoryException e )

         {

             throw new Exception( "Repository exception occurred." );

         }

         return new Boolean( true );

     }

     /**

      * @see AdministrationService#executeDatabaseScanner()

      */

     public Boolean executeDatabaseScanner() throws Exception

     {

         if ( taskScheduler.isProcessingDatabaseTask() )

         {

             return false;

         }

         log.info( "Queueing database task on request from administration service" );

         DatabaseTask task = new DatabaseTask();

         taskScheduler.queueDatabaseTask( task );           

         return new Boolean( true );

     }

     /**

      * @see AdministrationService#executeRepositoryScanner(String)

      */

     public Boolean executeRepositoryScanner( String repoId ) throws Exception

     {

         Configuration config = archivaConfiguration.getConfiguration();

         if( config.findManagedRepositoryById( repoId ) == null )

         {

             throw new Exception( "Repository does not exist." );

         }

         if ( taskScheduler.isProcessingRepositoryTask( repoId ) )

         {

             return false;

         }

         RepositoryTask task = TaskCreator.createRepositoryTask( repoId );

         taskScheduler.queueRepositoryTask( task );          

         return new Boolean( true );

     }

     /**

      * @see AdministrationService#getAllDatabaseConsumers()

      */

     public List<String> getAllDatabaseConsumers()

     {

         List<String> consumers = new ArrayList<String>();

         List<DatabaseCleanupConsumer> cleanupConsumers = dbConsumersUtil.getAvailableCleanupConsumers();

         List<DatabaseUnprocessedArtifactConsumer> unprocessedConsumers = dbConsumersUtil.getAvailableUnprocessedConsumers();

         for( DatabaseCleanupConsumer consumer : cleanupConsumers )

         {

             consumers.add( consumer.getId() );

         }  

         for( DatabaseUnprocessedArtifactConsumer consumer : unprocessedConsumers )

         {

             consumers.add( consumer.getId() );

         } 

         return consumers;

     }

     /**

      * @see AdministrationService#getAllRepositoryConsumers()

      */

     public List<String> getAllRepositoryConsumers()

     {

         List<String> consumers = new ArrayList<String>();

         List<KnownRepositoryContentConsumer> knownConsumers = repoConsumersUtil.getAvailableKnownConsumers();

         List<InvalidRepositoryContentConsumer> invalidConsumers = repoConsumersUtil.getAvailableInvalidConsumers();

         for( KnownRepositoryContentConsumer consumer : knownConsumers )

         {

             consumers.add( consumer.getId() );

         }

         for( InvalidRepositoryContentConsumer consumer : invalidConsumers )

         {

             consumers.add( consumer.getId() );

         }

         return consumers;

     }

     /**

      * @see AdministrationService#getAllManagedRepositories()

      */

     public List<ManagedRepository> getAllManagedRepositories()

     {

         List<ManagedRepository> managedRepos = new ArrayList<ManagedRepository>();

         Configuration config = archivaConfiguration.getConfiguration();

         List<ManagedRepositoryConfiguration> managedRepoConfigs = config.getManagedRepositories();

         for( ManagedRepositoryConfiguration repoConfig : managedRepoConfigs )

         {

             // TODO fix resolution of repo url!            

             ManagedRepository repo =

                 new ManagedRepository( repoConfig.getId(), repoConfig.getName(), "URL", repoConfig.getLayout(),

                                        repoConfig.isSnapshots(), repoConfig.isReleases() );  

             managedRepos.add( repo );

         }

         return managedRepos;

     }

     /**

      * @see AdministrationService#getAllRemoteRepositories()

      */

     public List<RemoteRepository> getAllRemoteRepositories()

     {

         List<RemoteRepository> remoteRepos = new ArrayList<RemoteRepository>();

         Configuration config = archivaConfiguration.getConfiguration();

         List<RemoteRepositoryConfiguration> remoteRepoConfigs = config.getRemoteRepositories();

         for( RemoteRepositoryConfiguration repoConfig : remoteRepoConfigs )

         {

             RemoteRepository repo =

                 new RemoteRepository( repoConfig.getId(), repoConfig.getName(), repoConfig.getUrl(),

                                       repoConfig.getLayout() );

             remoteRepos.add( repo );

         }

         return remoteRepos;

     }

     private void saveConfiguration( Configuration config )

         throws Exception

     {

         try

         {

             archivaConfiguration.save( config );

         }

         catch(  RegistryException e )

         {

             throw new Exception( "Error occurred in the registry." );

         }

         catch ( IndeterminateConfigurationException e )

         {

             throw new Exception( "Error occurred while saving the configuration." );    

         }

     }

 }