/**
    * Copyright 2006 woelfle
    * 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.tratoo.mdd.kernel.transformation.impl;
  
  import java.io.File;
  import java.net.URI;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  import org.tratoo.mdd.kernel.AmbiguousConfigurationException;
  import org.tratoo.mdd.kernel.Domain;
  import org.tratoo.mdd.kernel.Repository;
  import org.tratoo.mdd.kernel.RepositoryFactory;
  import org.tratoo.mdd.kernel.TransformationChain;
  import org.tratoo.mdd.kernel.TratooRuntimeException;
  import org.tratoo.mdd.kernel.emitter.Emitter;
  import org.tratoo.mdd.kernel.emitter.EmitterEngine;
  import org.tratoo.mdd.kernel.emitter.EmitterException;
  import org.tratoo.mdd.kernel.transformation.RunConfiguration;
  import org.tratoo.mdd.kernel.transformation.Transformation;
  import org.tratoo.mdd.kernel.transformation.TransformationEngine;
  
  /**
   * Default implementation of the {@link TransformationEngine} interface.
   * @see TransformationEngine
   * @author woelfle
   *
   */
  public final class TransformationEngineImpl implements TransformationEngine
  {
  	private final TransformationRepository trafoRepository = new TransformationRepository();
  		
  	/**
  	 * @see TransformationEngine#run(RunConfiguration)
  	 * @param runConfig @see {@link TransformationEngine#run(RunConfiguration)}
  	 * @return @see {@link TransformationEngine#run(RunConfiguration)}
  	 */
  	public Collection<Object> run(final RunConfiguration runConfig)
  	{
  		final Collection<Object> results = new ArrayList<Object>();
  
  		// Create a new TransformationExecutor
  		final ExecutionContext executionContext = new ExecutionContext(runConfig.getSourceRepository(), runConfig.getTargetRepository(), runConfig.getTransformation());
  		final TransformationRun executor = new TransformationRun(trafoRepository, executionContext);
  
  		for(Object element : runConfig.getSourceElements())
  		{
  			// Execute the transformation
  			results.addAll(executor.run(element));		
  		}
  				
  		return results;
  	}
  	
  	public boolean execute(TransformationChain chain)
  	{
  		boolean bResult = false;
  		
  		if(canExecute(chain))
  		{
  			// Ok. Seems that we can execute the transformation chain.
  			Repository sourceRepository = chain.getSourceRepository();
  			Repository targetRepository = null;
  			if(chain.getTargetDomain() == null)
  			{
  				targetRepository = sourceRepository;
  			}
  			else
  			{
  				TransformationPath path = findPath(chain.getSourceRepository().getDomain(), chain.getTargetDomain()).iterator().next();
  				for(Transformation trafo : path.transformations)
  				{
  					if(trafo.getTargetDomainID().equals(chain.getTargetDomain()) && chain.getTargetRepository() != null)
  					{
  						targetRepository = chain.getTargetRepository();
  					}
  					else
  					{
  						URI id = trafo.getTargetDomainID();
  						targetRepository = createRepository(id);
  					}
  					final ExecutionContext executionContext = new ExecutionContext(sourceRepository, targetRepository, trafo);
  					final TransformationRun executor = new TransformationRun(trafoRepository, executionContext);
  					for(Object element : chain.getSourceElements())
 					{
 						executor.run(element);					
 					}
 				}
 			}
 			
 			// Now perform the emitting
 			// TODO Refactor this code block. Looks ugly
 			Class emitterClass = chain.getEmitter();
 			if(emitterClass != null)
 			{
 				for(Emitter emitter : trafoRepository.getEmitters())
 				{
 					if(emitterClass.isAssignableFrom(emitter.getClass()))
 					{
 						Class emitterEngineClass = emitter.getEmitterEngine();
 						try
 						{
 							EmitterEngine engine = (EmitterEngine) emitterEngineClass.newInstance();
 							File rootDir = chain.getRootDir();
 							Collection sourceElements = targetRepository.getAllElements();
 							org.tratoo.mdd.kernel.emitter.RunConfiguration config = new org.tratoo.mdd.kernel.emitter.RunConfiguration(sourceElements, emitterClass, rootDir);
 							engine.registerEmitter(emitter);
 							engine.emit(config);
 						}
 						catch (InstantiationException e)
 						{
 							throw new TratooRuntimeException("Unable to create emitter engine <" + emitterEngineClass + "> for emitter <" + emitter + ">", e);
 						}
 						catch (IllegalAccessException e)
 						{
 							throw new TratooRuntimeException("Unable to create emitter engine <" + emitterEngineClass + "> for emitter <" + emitter + ">", e);
 						}
 						catch (EmitterException e)
 						{
 							throw new TratooRuntimeException("Unable to emit using emitter <"+emitter+">, rootDir <"+chain.getRootDir()+">", e);
 						}
 						catch (AmbiguousConfigurationException e)
 						{
 							throw new TratooRuntimeException("Unable to register emitter.", e);
 						}
 					}
 				}
 			}
 		}
 		else
 		{
 			bResult = false;
 		}
 		
 		chain.setStatus(TransformationChain.Status.success);
 		
 		return bResult;
 	}
 	
 	protected Repository createRepository(URI domainId)
 	{
 		Repository repository = null;
 		return repository;
 	}
 	
 	/**
 	 * Checks whether the given {@link TransformationChain}
 	 * can be executed. Returns <code>true</code> if it can
 	 * be executed. Otherwise <code>false</code> is returned.
 	 * If the chain cannot be executed then descriptions on 
 	 * what happened can be found in the 
 	 * {@link TransformationChain#getWarnings()} collection.
 	 * @param chain The {@link TransformationChain} to check.
 	 * @return
 	 */
 	public boolean canExecute(TransformationChain chain)
 	{
 		boolean canExecute = false;
 		
 		// Check whether we have to perform a transformation.
 		// In that case a path has to exist from the source to
 		// the target domain. Otherwise only an emitting should
 		// be performed and no path is needed.		
 		Domain sourceDomain = chain.getSourceRepository().getDomain();
 		Domain targetDomain = chain.getTargetDomain();
 		if(targetDomain != null && !sourceDomain.equals(targetDomain))
 		{
 			List<TransformationPath> paths = findPath(sourceDomain, targetDomain);
 			if(paths.size() == 0)
 			{
 				String message = "No transformation path found from source domain <" + 
 					sourceDomain.getID() + "> to target domain <" + 
 					targetDomain.getID() + ">";
 				chain.getWarnings().add(message);
 			}
 			else if(paths.size() > 1)
 			{
 				String message = "Found more than one path from source domain <" +
 					sourceDomain.getID() + "> to target domain <" +
 					targetDomain.getID() + ">.\nFound paths: \n";
 				
 				for(TransformationPath path : paths)
 				{
 					message += "(sourceDomain->";
 					for(Transformation trafo : path.transformations)
 					{
 						message += trafo + "->";
 					}
 					message += "targetDomain)\n";
 				}				
 				chain.getWarnings().add(message);
 			}
 		}
 		else
 		{
 			canExecute = true;			
 		}
 				
 		return canExecute;
 	}	
 	
 	protected List<TransformationPath> findPath(Domain source, Domain target)
 	{
 		return findPath(source.getID(), target.getID(), new HashSet<URI>());		
 	}
 	
 	private List<TransformationPath> findPath(URI source, URI target, Set<URI> alreadyVisited)
 	{
 		List<TransformationPath> paths = new ArrayList<TransformationPath>();
 		for(Transformation trafo : getTransformations())
 		{
 			if(trafo.getSourceDomainID().equals(source))
 			{
 				// Found transformation with matching source domain.
 				URI tmpURI = trafo.getTargetDomainID();
 				
 				// Check whether the target domain of the transformation
 				// matches the target of the path.
 				if(tmpURI.equals(target))
 				{
 					// Ok. We have found the first part of a path. Create
 					// a new TransformationPath instance and add the transformation
 					// to it.
 					TransformationPath path = new TransformationPath();
 					path.transformations.add(trafo);
 					paths.add(path);
 				}
 				
 				// Check whether the target domain of the transformation
 				// has already been visited.
 				if(!alreadyVisited.contains(tmpURI))
 				{
 					// Ok. We have not yet visited the target domain.
 					// So add lets visit it.
 					Set<URI> newVisited = new HashSet<URI>(alreadyVisited);
 					newVisited.add(source);
 					paths = findPath(tmpURI, target, newVisited);
 					
 					// Check whether paths have been found. If true, then add the current
 					// transformation to all paths.
 					for(TransformationPath path : paths)
 					{
 						path.transformations.add(trafo);
 					}
 				}
 			}				
 		}
 		return paths;
 	}
 	
 	/**
 	 * @param transformation @see {@link TransformationEngine#registerTransformation(Transformation)}
 	 */
 	public void registerTransformation(final Transformation transformation)
 	{
 		trafoRepository.registerTransformation(transformation);
 	}
 	
 	/**
 	 * @param transformation @see {@link TransformationEngine#unregisterTransformation(Transformation)}
 	 */
 	public void unregisterTransformation(final Transformation transformation)
 	{
 		trafoRepository.unregisterTransformation(transformation);
 	}
 	
 	/**
 	 * @param domain @see {@link TransformationEngine#registerDomain(Domain)}
 	 */
 	public void registerDomain(final Domain domain)
 	{
 		trafoRepository.registerDomain(domain);
 	}
 	
 	/**
 	 * @param domain @see {@link TransformationEngine#unregisterDomain(Domain)}
 	 */
 	public void unregisterDomain(final Domain domain)
 	{
 		trafoRepository.unregisterDomain(domain);
 	}
 	
 	/**
 	 * @return @see {@link TransformationEngine#getDomains()}
 	 */
 	public Set<Domain> getDomains()
 	{
 		return trafoRepository.getDomains();
 	}
 	
 	/**
 	 * @return @see {@link TransformationEngine#getTransformations()}
 	 */
 	public Set<Transformation> getTransformations()
 	{
 		return trafoRepository.getTransformations();
 	}
 
 	public Set<Emitter> getEmitters()
 	{
 		return trafoRepository.getEmitters();
 	}
 
 	public void registerEmitter(Emitter emitter)
 	{
 		trafoRepository.registerEmitter(emitter);
 	}
 
 	public void unregisterEmitter(Emitter emitter)
 	{
 		trafoRepository.unregisterEmitter(emitter);
 	}
 	
 	public void registerRepositoryFactory(RepositoryFactory factory)
 	{
 		trafoRepository.registerRepositoryFactory(factory);
 	}
 
 	public void unregisterRepositoryFactory(RepositoryFactory factory)
 	{
 		trafoRepository.unregisterRepositoryFactory(factory);		
 	}
 	
 	public Set<RepositoryFactory> getRepositoryFactories()
 	{
 		return trafoRepository.getRepositoryFactories();
 	}
 
 	private class TransformationPath
 	{
 		public final List<Transformation> transformations = new ArrayList<Transformation>();
 	}
 }