/**
    * Copyright 2005-2006 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.businessobjects.commons.Release;
  import org.figure8.join.businessobjects.artifact.Build;
  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.persistence.BuildDao;
  import org.figure8.join.businessobjects.artifact.persistence.AssemblyDao;
  import org.figure8.join.businessfacades.reporting.EventPublicationManager;
  import org.figure8.join.util.LogUtil;
  
  import org.apache.commons.logging.Log;
  
  import java.util.Map;
  import java.util.List;
  import java.util.Iterator;
  /**
   * This is the default implementation of {@link AssemblyManager}
   * @author  <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.3 $
   */
  public class DefaultAssemblyManager implements AssemblyManager{
  
     // Static -------------------------------------------------------------------
  
     /** Get a commons logger. */
     private static final Log log = LogUtil.getLog(DefaultAssemblyManager.class);
  
  
     // Attributes ---------------------------------------------------------------
  
     /** Build data access object */
     protected BuildDao buildDao = null;
     /** Assembly data access object */
     protected AssemblyDao assemblyDao = null;
     /** The ArtifactManager to use */
     protected ArtifactManager artifactManager = null;
     /** The EventPublicationManager to use */
     protected EventPublicationManager publicationManager = null;
  
  
     // Constructors -------------------------------------------------------------
  
     /** Creates a new instance of DefaultAssemblyManager */
     public DefaultAssemblyManager(){
     }
  
  
     // Public -------------------------------------------------------------------
  
     /** @param buildDao A Build data access object */
     public void setBuildDao(BuildDao buildDao){
        this.buildDao = buildDao;
     }
     /** @param assemblyDao A Assembly data access object */
     public void setAssemblyDao(AssemblyDao assemblyDao){
        this.assemblyDao = assemblyDao;
     }
     /** @param artifactManager The ArtifactManager implementation to use */
     public void setArtifactManager(ArtifactManager artifactManager){
        this.artifactManager = artifactManager;
     }
     /** @param publicationManager The EventPublicationManager implementation to use */
     public void setEventPublicationManager(EventPublicationManager publicationManager){
        this.publicationManager = publicationManager;
     }
  
  
     // Implementation of AssemblyManager ----------------------------------------
  
     /**
      * Save a specified assembly (indeed a save or update method)
      * @param assembly The assembly to save within datastore
      * @param deliverables A list of deliverables composing the assembly to create
      * @throws DuplicateEntityException if another assembly with same deliverables already exists
      */
     public void saveAssembly(Assembly assembly, List deliverables) throws DuplicateEntityException{
        if (log.isInfoEnabled())
           log.info("Creating a new Assembly with key '" + assembly.getKey() + "'");
  
        // Set a flag telling if it's a new assembly.
        boolean newAssembly = assembly.isTransient();
 
       if (newAssembly){
          // If new one, check that there's no other assembly with this key.
          Assembly other = assemblyDao.getAssembly(assembly.getKey());
          if (other != null){
             log.error("An Assembly with same key already exists: " + other.getKey());
             throw new DuplicateEntityException("An Assembly with same key already exists", other);
          }
          // Ensure no other assembly with same deliverables exists too.
          List others = assemblyDao.getAssembliesWithDeliverables(deliverables);
          if (others != null && !others.isEmpty() && !others.contains(assembly)){
             log.error("An Assembly with same deliverables already exists: " + ((Assembly)others.get(0)).getKey());
             throw new DuplicateEntityException("An Assembly with same deliverables already exists", (Assembly)others.get(0));
          }
          // Add deliverables to assembly and call save on dao.
          assembly.getDeliverables().clear();
          for (int i=0; i<deliverables.size(); i++){
             Deliverable deliverable = (Deliverable)deliverables.get(i);
             assembly.addDeliverable(deliverable);
          }
       }
       // Call save() on dao.
       assemblyDao.save(assembly);
       // Publish a message if it's a new assembly.
       if (newAssembly)
          publicationManager.publishAssemblyCreationEvent(assembly);
    }
    
    /**
     * Retrieve all assemblies created for specified release
     * @param release The release to get assemblies for
     * @return A list of {@code org.figure8.join.businessobjects.artifact.Assembly} objects
     */
    public List getAssemblies(Release release){
       return assemblyDao.getAssembliesByRelease(release);
    }
    
    /**
     * Retrieve an Assembly using its unique key
     * @param key The unique key of assembly to retrieve
     * @return The corresponding assembly or null if no assembly has this key
     */
    public Assembly getAssembly(String key){
       return assemblyDao.getAssembly(key);
    }
 
    /**
     * Save a Build for a specified release (indeed a create or update method).
     * @param build The build to save within datastore.
     * @param components A list of Components composing the build to create
     * @param extractedComponents A map representing components to extract from an assembly.
     *    Key of map entry is a component type and value is the assembly to extract this component from.
     * @throws DuplicateEntityException if another build with same component already exists
     */
    public void saveBuild(Build build, List components, Map extractedComponents) throws DuplicateEntityException{
       if (log.isInfoEnabled())
          log.info("Saving the Build with key '" + build.getKey() + "'");
 
       // Set a flag telling if it's a new build.
       boolean newBuild = build.isTransient();
 
       // Only save components for new builds.
       if (newBuild){
          // Check that no other build with same key already exist.
          Build other = buildDao.getBuild(build.getKey());
          if (other != null){
             log.error("A Build with same key already exists: " + other.getKey());
             throw new DuplicateEntityException("A Build with same key already exists", other);
          }
 
          // Deal with components that may be extacted.
          if (extractedComponents != null){
             Iterator types = extractedComponents.keySet().iterator();
             while (types != null && types.hasNext()){
                ComponentType type = (ComponentType)types.next();
                Assembly assembly = (Assembly)extractedComponents.get(type);
                // Sanity check...
                if (assembly != null){
                   // Get this component from assembly if existing...
                   Component component = assembly.getComponent(type);
                   if (component == null){
                      // .. or create and bind a new one.
                      if (log.isDebugEnabled())
                         log.debug("Creating a new component of type '"
                                 + type.getLabel() + "', extracted from " + assembly.getKey());
                      component = new Component(assembly.getKey(), -1, type);
                      artifactManager.bindComponent(component, assembly);
                   }
                   components.add(component);
                }
             }
          }
          // Ensure no other build with same deliverables exists too.
          List others = buildDao.getBuildsWithComponents(components);
          if (others != null && !others.isEmpty() && !others.contains(build)){
             log.error("A Build with same components already exists: " + ((Build)others.get(0)).getKey());
             throw new DuplicateEntityException("A Build with same component already exists", (Build)others.get(0));
          }
 
          // Add components to build and call save on dao.
          build.getComponents().clear();
          for (int i=0; i<components.size(); i++){
             Component component = (Component)components.get(i);
             build.addComponent(component);
          }
       }
       // Call save() on dao and publish a message.
       buildDao.save(build);
       // Publish a message if it's a new build.
       if (newBuild)
          publicationManager.publishBuildCreationEvent(build);
    }
    
    /**
     * Retrieve all builds created for specified release
     * @param release The release to get builds for
     * @return A list of {@code org.figure8.join.businessobjects.artifact.Build} objects
     */
    public List getBuilds(Release release){
       // Delegate call to dao.
       return buildDao.getBuildsByRelease(release);
    }
    
    /**
     * Retrieve a Build using its unique key
     * @param key The unique key of build to retrieve
     * @return The corresponding build or null if no build has this key
     */
    public Build getBuild(String key){
       // Delegate call to dao.
       return buildDao.getBuild(key);
    }
 }