/**
    * Copyright 2005-2007 the original author or authors.
    *
    * Licensed under the Gnu General Pubic 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.opensource.org/licenses/gpl-license.php
    *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   * See the Gnu General Public License for more details.
   */
  package org.figure8.join.businessfacades.artifact;
  
  import org.figure8.join.core.DuplicateEntityException;
  import org.figure8.join.core.InvalidParameterException;
  import org.figure8.join.core.InfrastructureException;
  import org.figure8.join.services.vcs.VCSAccessor;
  import org.figure8.join.services.vcs.VCSAccessException;
  import org.figure8.join.services.repository.Repository;
  import org.figure8.join.services.repository.RepositoryException;
  import org.figure8.join.businessobjects.commons.Release;
  import org.figure8.join.businessobjects.artifact.Assembly;
  import org.figure8.join.businessobjects.artifact.Component;
  import org.figure8.join.businessobjects.artifact.Deliverable;
  import org.figure8.join.businessobjects.artifact.ComponentType;
  import org.figure8.join.businessobjects.artifact.DeliverableType;
  import org.figure8.join.businessobjects.artifact.persistence.ComponentDao;
  import org.figure8.join.businessobjects.artifact.persistence.DeliverableDao;
  import org.figure8.join.businessobjects.artifact.persistence.ComponentTypeDao;
  import org.figure8.join.businessobjects.artifact.persistence.DeliverableTypeDao;
  import org.figure8.join.businessfacades.reporting.EventPublicationManager;
  import org.figure8.join.util.LogUtil;
  
  import org.apache.commons.logging.Log;
  
  import java.io.File;
  import java.io.InputStream;
  import java.util.List;
  /**
   * This is the default implementation of {@link ArtifactManager}.
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.3 $
   */
  public class DefaultArtifactManager implements ArtifactManager{
  
     // Static -------------------------------------------------------------------
  
     /** Get a commons logger... */
     private static final Log log = LogUtil.getLog(DefaultArtifactManager.class);
  
  
     // Attributes ---------------------------------------------------------------
  
     /** Component data access object */
     protected ComponentDao componentDao = null;
     /** Deliverable data access object */
     protected DeliverableDao deliverableDao = null;
     /** Component type data access object */
     protected ComponentTypeDao componentTypeDao = null;
     /** Deliverable type data access object */
     protected DeliverableTypeDao deliverableTypeDao = null;
     /** The event publication manager implementation for reporting events */
     protected EventPublicationManager publicationManager = null;
  
     /** The Repository implementation to use for storing deliverables */
     protected Repository deliverablesRepository = null;
  
  
     // Constructors -------------------------------------------------------------
     
     /** Creates a new instance of DefaultArtifactManager */
     public DefaultArtifactManager(){
     }
     
     
     // Public -------------------------------------------------------------------
  
     /** @param dao A Component data access object */
     public void setComponentDao(ComponentDao dao){
        this.componentDao = dao;
     }
     /** @param dao A Deliverable data access object */
     public void setDeliverableDao(DeliverableDao dao){
        this.deliverableDao = dao;
     }
     /** @param dao A Component type data access object */
     public void setComponentTypeDao(ComponentTypeDao dao){
        this.componentTypeDao = dao;
     }
     /** @param dao A Deliverable type data access object */
     public void setDeliverableTypeDao(DeliverableTypeDao dao){
        this.deliverableTypeDao = dao;
     }
     /** @param manager A Event publication manager implementation instance */
     public void setEventPublicationManager(EventPublicationManager manager){
        this.publicationManager = manager;
    }
 
 
    // Implementation of ArtifactManager -------------------------------------
   
    /**
     * Bind a component to an existing assembly. If component is not already
     * registered, create it. And update its reference assembly (the one that
     * first contains the component)
     * @param component The component to bind to assembly
     * @param assembly The assembly that is containing component
     */
    public void bindComponent(Component component, Assembly assembly){
       if (log.isDebugEnabled())
          log.debug("Binding component '" + component.getKey() + "' to assembly " + assembly.getKey());
       // If it's a new component, set its origin assembly.
       Component other = componentDao.getComponent(component.getKey());
       if (component.isTransient() && other == null){
          log.info("Creating a new component '" + component.getKey() + "' from assembly " + assembly.getKey());
          component.setAssembly(assembly);
       }
       // In any case, add this assembly to component.
       assembly.addComponent(component);
       // Create or update component.
       componentDao.save(component);
    }
 
    /**
     * Get a component having this specified key.
     * @param key Unique business identifier of component to retrieve
     * @return The component having this business key
     */
    public Component getComponent(String key){
       // Delegate to dao.
       return componentDao.getComponent(key);
    }
 
    /**
     * Retrieve a list of components corresponding to the specified type and created into release
     * @param type The component type of the components to retrieve
     * @param release The release the components have been bound to
     * @return A list of {@code org.figure8.join.businessobjects.artifact.Component}s
     */
    public List getComponents(ComponentType type, Release release){
       // Delegate to dao.
       return componentDao.getComponentsByRelease(type, release);
    }
 
    /**
     * Retrieve a list of components of the specified type and contained into release
     * @param type The component type of the components to retrieve
     * @param release The release the components have been bound to
     * @return A list of {@code org.figure8.join.businessobjects.artifact.Component}s
     */
    public List getContainedComponents(ComponentType type, Release release){
       // Delegate to dao.
       return componentDao.getComponentsInRelease(type, release);
    }
 
    /**
     * Save a component type within datastore
     * @param type Type to save (create or update)
     * @throws DuplicateEntityException if another type with same key already exists
     */
    public void saveComponentType(ComponentType type) throws DuplicateEntityException{
       if (log.isInfoEnabled())
          log.info("Saving ComponentType with key '" + type.getKey() + "'");
       // If new type, look if another one with same key exists.
       if (type.isTransient()){
          ComponentType other = componentTypeDao.getComponentType(type.getKey());
          if (other != null){
             log.error("A ComponentType with same key already exists: " + other.getLabel());
             throw new DuplicateEntityException("A ComponentType with same key already exists", other);
          }
       }
       // Call save() on dao.
       componentTypeDao.save(type);
    }
 
    /**
     * Get a component category having the specified key.
     * @param key Unique business identifier of the component type to retrieve
     * @return ComponentType having this <b>key</b>
     */
    public ComponentType getComponentType(String key){
       return componentTypeDao.getComponentType(key);
    }
 
    /**
     * Retrieve the component types (or category) of software.
     * @return List of available {@code org.figure8.join.businessobjects.artifact.ComponentType}
     */
    public List getComponentTypes(){
       // Call findAll() on dao.
       List result = componentTypeDao.findAllSorted("label");
       if (log.isDebugEnabled())
          log.debug("Found " + result.size() + " component types for project");
       return result;
    }
 
    /**
     * Create a deliverable within datastore and register its content. The
     * stream parameter may be null if deliverable content should be retrievied
     * through a SCM extraction or some other mean ...
     * @param deliverable The new deliverable to register within Join application
     * @param content The stream containing deliverable content (if any)
     * @throws InvalidParameterException if deliverable is already registered
     * @throws DuplicateEntityException if another deliverable with same key already exists
     */
    public void registerDeliverable(Deliverable deliverable, InputStream content)
            throws InvalidParameterException, DuplicateEntityException{
       log.info("Registering a new deliverable with key '" + deliverable.getKey() + "'");
 
       // First ensure that it is not an update.
       if (!deliverable.isTransient()){
          log.error("The Deliverable with key '" + deliverable.getKey() + "' has already been registered");
          throw new InvalidParameterException("The Deliverable '" + deliverable.getKey() + "' is already registered");
       }
       // Now check that there's no other deliverable with this key.
       Deliverable other = deliverableDao.getDeliverable(deliverable.getKey());
       if (other != null){
          log.error("A Deliverable with same key already exists: " + other.getKey());
          throw new DuplicateEntityException("A Deliverable with same key already exists", other);
       }
       // Extract deliverable content from SCM if necessary.
       File directory = null;
       if (deliverable.getDeliverableType().getVcsDeliverable()){
          try {directory = extractDeliverableFromVcs(deliverable);}
          catch (VCSAccessException vcse){
             // Log and wrap into a runtime exception.
             log.error("Exception while trying to checkout '" + deliverable.getKey() + "' from SCM");
             log.error("Here's the detailed message: " + vcse.getMessage());
             throw new InfrastructureException("Exception while trying to extract '"
                     + deliverable.getKey() + "' from SCM", vcse);
          }
       }
       // Store deliverable content into repository.
       try{
          if (content != null) deliverablesRepository.storeArtifact(deliverable, content);
          else if (directory != null) deliverablesRepository.storeArtifact(deliverable, directory);
       }
       catch (RepositoryException re){
          // Log and wrap into a runtime exception.
          log.error("Exception while trying to store '" + deliverable.getKey() + "' into Repository");
          log.error("Here's the detailed message: " + re.getMessage());
          throw new InfrastructureException("Exception while trying to store '"
             + deliverable.getKey() + "' into Repository", re);
       }
       // Call save on dao and publish an event.
       deliverableDao.save(deliverable);
       publicationManager.publishDeliveryEvent(deliverable);
    }
 
    /**
     * Save a deliverable within datastore. This method should be used only for
     * updating existing deliverables. They must have been first created using the
     * <code>registerDeliverable()</code> method.
     * @param deliverable The deliverable to save (just an update)
     * @throws InvalidParameterException if deliverable has not been registered before
     */
    public void saveDeliverable(Deliverable deliverable) throws InvalidParameterException{
       log.info("Saving the deliverable with key '" + deliverable.getKey() + "'");
 
       // First, ensure of registration.
       if (deliverable.isTransient()){
          log.error("The Deliverable with key '" + deliverable.getKey() + "' has not been registered before");
          throw new InvalidParameterException("The Deliverable should be registered before saved !");
       }
       // Call save on dao.
       deliverableDao.save(deliverable);
    }
 
    /**
     * Get a deliverable having this specified key.
     * @param key Unique business identifier of deliverable to retrieve
     * @return The deliverable having this business key
     */
    public Deliverable getDeliverable(String key){
       return deliverableDao.getDeliverable(key);
    }
 
    /**
     * Retrieve a list of deliverables corresponding to the specified type
     * @param type The deliverable type of the deliverables to retrieve
     * @param maxResult An int to limit the size of list returned
     * @return A list of {@code org.figure8.join.businessobjects.artifact.Deliverable}s
     */
    public List getLastDeliverables(DeliverableType type, int maxResult){
       // Delegate to dao.
       List result = deliverableDao.getLastDeliverables(type, maxResult);
       if (log.isDebugEnabled())
          log.debug("Found " + result.size() + " last deliberables of type " + type.getLabel());
       return result;
    }
 
    /**
     * Retrieve a list of deliverables corresponding to the specified type for this release
     * @param type The deliverable type of the deliverables to retrieve
     * @param release The release the deliverables have been bound to
     * @return A list of {@code org.figure8.join.businessobjects.artifact.Deliverable}s
     */
    public List getDeliverables(DeliverableType type, Release release){
       // Delegate to dao.
       List result = deliverableDao.getDeliverablesByRelease(type, release);
       if (log.isDebugEnabled())
          log.debug("Found " + result.size() + " deliberables of type "
                  + type.getLabel() + " for release '" + release.getName() + "'");
       return result;
    }
 
    /**
     * Set the repository to use for storing deliverables. This repository
     * is necessary when registering a new Deliverables.
     * @param repository The repository for storing deliverables content
     */
    public void setDeliverablesRepository(Repository repository){
       this.deliverablesRepository = repository;
    }
 
    /**
     * Save a deliverable type within datastore. If type is a newly created type,
     * its key should a non existing one. Otherwise, a DuplicateEntityException will
     * thrown. If type is already existing, the key is an immutable field an a runtime
     * exception exception will be thrown if it has changed.
     * @param type Type to save (create or update)
     * @throws DuplicateEntityException if another type with same key already exists
     */
    public void saveDeliverableType(DeliverableType type) throws DuplicateEntityException{
       if (log.isInfoEnabled())
          log.info("Saving DeliverableType with key '" + type.getKey() + "'");
       // If new type, look if another one with same key exists.
       if (type.isTransient()){
          DeliverableType other = getDeliverableType(type.getKey());
          if (other != null){
             log.error("A DeliverableType with same key already exists: " + other.getLabel());
             throw new DuplicateEntityException("A DeliverableType with same key already exists", other);
          }
       }
       // Call save() on dao.
       deliverableTypeDao.save(type);
    }
 
    /**
     * Get a deliverable category having the specified key.
     * @param key Unique business identifier of the deliverable type to retrieve
     * @return DeliverableType having this <b>key</b>
     */
    public DeliverableType getDeliverableType(String key){
       return deliverableTypeDao.getDeliverableType(key);
    }
 
    /**
     * Retrieve the deliverable types (or category) of software.
     * @return List of available {@code org.figure8.join.businessobjects.artifact.DeliverableType}
     */
    public List getDeliverableTypes(){
       // Call findAll() on dao.
       List result = deliverableTypeDao.findAll();
       if (log.isDebugEnabled())
          log.debug("Found " + result.size() + " deliberable types for project");
       return result;
    }
 
 
    // Private ------------------------------------------------------------------
 
    /**
     * Extract deliverable coming from SCM into a local directory
     * @param deliverable The description of deliverable to checkout
     * @throws InvalidParameterException if VCSAccessor cannot be initialized
     * @throws VCSAccessException if checkout cannot be done
     * @return The File representing directory where checkout was done
     */
    private File extractDeliverableFromVcs(Deliverable deliverable) throws InvalidParameterException, VCSAccessException{
       // Extract into a temporary file.
       String tmp = System.getProperty("java.io.tmpdir");
       File tmpDir = new File(tmp, deliverable.getKey());
       tmpDir.mkdir();
       tmpDir.deleteOnExit();
       // Now, retrieve accessor to checkout.
       VCSAccessor accessor = deliverable.getDeliverableType().getVCSAccessor();
       if (log.isInfoEnabled()){
          log.info("Temporary directory created for checking out '" + deliverable.getKey() + "': " + tmpDir.getPath());
          log.info("Trying to checkout from SCM " + accessor.getRootRepository() + "...");
       }
       // Do the login -> checkout -> logout command.
       accessor.login();
       accessor.checkout(deliverable.getVersionInfo(), tmpDir.getPath());
       accessor.logout();
 
       return tmpDir;
    }
 }