/*
    Copyright (C) 2006 Grid Systems, S.A.
   
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
   
    This library 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
   Lesser General Public License for more details.
  
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
  package com.gridsystems.nextgrid.api.pom;
  
  import java.net.URI;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.PriorityQueue;
  
  import javax.xml.namespace.QName;
  
  import nextgrid.api.env.DiscoveryException;
  import nextgrid.api.env.Prioritiser;
  import nextgrid.api.env.ProcessDiscoverer;
  import nextgrid.api.env.ProcessEnvironment;
  import nextgrid.api.env.ProcessSelector;
  import nextgrid.api.env.SelectionException;
  import nextgrid.api.pem.DiscoveryEvent;
  import nextgrid.api.pem.ProcessEvent;
  import nextgrid.api.pom.AbstractProcess;
  import nextgrid.api.pom.Process;
  import nextgrid.api.pom.ProcessController;
  import nextgrid.api.pom.ProcessException;
  import nextgrid.api.pom.QueryProfile;
  
  /**
   * A process with a semantic description, but no specific implementation
   * binding details.
   * <p>
   * Such an abstract process must be fulfilled with binding information or
   * "replaced" by a more specific, yet still abstract, process during enaction.
   * This replacement is really implemented through a child containment structure
   * to prevent losing original semantic data: In case of error, the enactor must
   * be able to revert to the original abstract description and repeat the
   * discovery phase to reach an alternative service provider.
   * <p>
   * The presence of instances of this class within a workflow representation
   * as leaf nodes marks this workflow as abstract, meaning that it will require
   * some extra process before being "executable".
   * <p>
   * In OWL-WS terms, an AbstractProcessImpl can be mapped to a service that only
   * contains a profile, but no grounding; that is, it only states service
   * constraints, but no capabilities.
   *
   * @author Rodrigo Ruiz
   */
  public final class AbstractProcessImpl extends ProcessImpl
    implements AbstractProcess {
  
    /**
     * <code>serialVersionUID</code> attribute.
     */
    private static final long serialVersionUID = -345106213089801350L;
  
    /**
     * List of candidate processes obtained through discovery.
     */
    private List<Process> candidates = null;
  
    /**
     * Current candidate.
     */
    private Process selected;
  
    /**
     * Priority value.
     */
    private int priority = UNDEFINED_PRIORITY;
  
    /**
     * Query profile.
     */
    private QueryProfile profile;
  
    /**
     * Creates an instance.
     */
    public AbstractProcessImpl() {
    }
  
    /**
    * Creates a new instance.
    *
    * @param profile The query profile that defines this process
    */
   public AbstractProcessImpl(QueryProfile profile) {
     this.profile = profile;
   }
 
   //----------------------------------------------------------------------------
   // Process Hierarchy Management
   //----------------------------------------------------------------------------
 
   /**
    * {@inheritDoc}
    */
   public List<Process> getCandidates() {
     return this.candidates;
   }
 
   /**
    * {@inheritDoc}
    */
   public void setCandidates(Collection<Process> candidates) {
     if (candidates == null) {
       this.candidates = null;
     } else {
       if (this.candidates == null) {
         this.candidates = new ArrayList<Process>(candidates);
       } else {
         this.candidates.clear();
         this.candidates.addAll(candidates);
       }
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public Process getSelected() {
     return this.selected;
   }
 
   /**
    * Sets the selected process.
    *
    * @param selected The new selected process
    */
   public void setSelected(Process selected) {
     if (this.selected != null) {
       this.selected.setParent(null);
     }
 
     this.selected = selected;
 
     if (this.selected != null) {
       this.selected.setParent(this);
     }
   }
 
   //----------------------------------------------------------------------------
   // Enaction Management
   //----------------------------------------------------------------------------
 
   /**
    * Gets the priority (evaluation order) of this process.
    *
    * @return The priority
    */
   public int getPriority() {
     return this.priority;
   }
 
   /**
    * Sets the priority (evaluation order) of this process.
    *
    * @param priority The new priority value
    */
   public void setPriority(int priority) {
     this.priority = priority;
   }
 
   /**
    * {@inheritDoc}
    */
   public QueryProfile getProfile() {
     return this.profile;
   }
 
   /**
    * {@inheritDoc}
    */
   public void setProfile(QueryProfile profile) {
     this.profile = profile;
   }
 
   /**
    * {@inheritDoc}
    */
   public Process findProcessById(URI id) {
     if (id == null) {
       return null;
     } else if (this.getId().equals(id)) {
       return this;
     } else if (this.getSelected() != null) {
       return this.getSelected().findProcessById(id);
     } else {
       return null;
     }
   }
 
   /**
    * {@inheritDoc}
    */
   @Override protected void doValidate(ValidationType when)
     throws ProcessException {
     // TODO Implement this method
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   public void doEvaluate(ProcessEnvironment env) throws ProcessException {
     this.selected = select(env);
     if (this.selected != null) {
       this.selected.evaluate(env);
     }
   }
 
   /**
    * Gets if this process has a priority defined.
    *
    * @return true if the priority of this process is defined
    */
   private boolean hasPriority() {
     return this.priority != UNDEFINED_PRIORITY;
   }
 
   /**
    * {@inheritDoc}
    */
   public void prioritise(ProcessEnvironment env, PriorityQueue<Process> queue)
     throws ProcessException {
 
     if (!queue.contains(this) && !isEvaluated() && !isLazy()) {
       if (!this.hasPriority()) {
         URI id = this.getId();
         Prioritiser prioritiser = env.getPrioritiserFor(id);
         if (prioritiser == null) {
           throw new ProcessException("No prioritiser found for process " + id);
         } else {
           prioritiser.prioritise(this);
         }
       }
       queue.offer(this);
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void discover(ProcessEnvironment env) throws ProcessException {
 
     if (this.getCandidates() == null) {
       ProcessDiscoverer disc = env.getDiscovererFor(this.getId());
 
       // No specific or default discoverer found. Try with the parent process
       Process p = this;
       while (disc == null && p.getParent() != null) {
         p = p.getParent();
         disc = env.getDiscovererFor(p.getId());
       }
 
       if (disc == null) {
         throw new DiscoveryException("No discoverer found for process " + this.getId());
       } else {
         fireDiscovererSelected(new DiscoveryEvent(disc, this));
         fireDiscoveryStarting(new DiscoveryEvent(disc, this, this.candidates));
         try {
           Collection<Process> found = disc.discover(this);
           if (found == null || found.isEmpty()) {
             throw new DiscoveryException("No candidates found");
           } else {
             this.setCandidates(found);
             fireDiscoveryFinished(new DiscoveryEvent(disc, this, this.candidates));
           }
         } catch (DiscoveryException e) {
           fireDiscoveryFailed(new DiscoveryEvent(disc, this, this.candidates, e));
           throw e;
         }
       }
     }
   }
 
   /**
    * Selects a process from a list of previously discovered candidates.
    *
    * @param env  The environment from where a selector is picked up
    * @return The selected process
    * @throws ProcessException If an error occurs
    */
   private Process select(ProcessEnvironment env) throws ProcessException {
     if (this.selected == null) {
       discover(env);
 
       URI id = this.getId();
 
       ProcessSelector selector = env.getSelectorFor(id);
       if (selector == null) {
         throw new ProcessException("No selector found for process " + id);
       } else {
         selector.select(this);
         if (this.selected != null) {
           this.selected.setParent(this);
           matchParameters(this.selected);
           //this.selected.evaluate(env);
           fireProcessSelected(new ProcessEvent(this.selected));
         }
       }
     }
     return this.selected;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override protected void doReset() {
     setCandidates(null);
     setSelected(null);
   }
 
   /**
    * {@inheritDoc}
    */
   @Override protected void resetChildren() {
     if (this.selected != null) {
       this.selected.reset();
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void run(ProcessContext ctx) throws ProcessException, InterruptedException {
     fireProcessStarted();
     waitForInputs();
 
     // Candidate discovery
     if (this.selected == null) {
       throw new SelectionException("No candidate selected for process '"
         + this.getId() + "'");
     } else {
       ProcessController controller = this.selected.enact(ctx);
       controller.run();
     }
 
     if (ctx.isRunning()) {
       fireProcessFinished();
     }
   }
 
   /**
    * {@inheritDoc}
    */
   @Override public String toString() {
     return "AbstractProcess#" + this.getId();
   }
 
   /**
    * Modifies the specified process, linking its inputs and outputs to the
    * ones in this abstract process.
    * <p>
    * The linkage is made by matching the last token of the parameter URIs for now.
    *
    * @param p The process to modify
    * @throws ProcessException If a parameter cannot be matched
    */
   private void matchParameters(Process p) throws ProcessException {
     // Match inputs
     for (String name : p.getUsedInputNames()) {
       String match = findInputMatch(name);
       if (match == null) {
         throw new ProcessException("Could not match input " + p.getId() + "#" + name);
       } else {
         p.putInput(name, this.getInput(match));
       }
     }
 
     for (String name : p.getUsedOutputNames()) {
       String match = findOutputMatch(name);
       if (match == null) {
         throw new ProcessException("Could not match output " + p.getId() + "#" + name);
       } else {
         p.putOutput(name, this.getOutput(match));
       }
     }
   }
 
   /**
    * Find a name matching the specified one in the given candidates list.
    *
    * @param name The name to match
    * @return A match, or null
    */
   private String findInputMatch(String name) {
     String[] usedNames = this.getUsedInputNames();
 
     // Build inputs map
     Map<String, String> inputMap = new HashMap<String, String>();
     for (Map.Entry<QName, String> entry : this.getAttributes().entrySet()) {
       QName qname = entry.getKey();
       if (qname.getNamespaceURI().equals("input-map")) {
         inputMap.put(entry.getValue(), qname.getLocalPart());
       }
     }
 
     // First: look for exact match in mapped inputs
     if (inputMap.containsKey(name)) {
       return inputMap.get(name);
     }
 
     // Second: look for exact match in current inputs
     for (String s : usedNames) {
       if (s.equals(name)) {
         return s;
       }
     }
 
     // Third: look for exact localName match in the mapped inputs
     String localName = name.substring(name.lastIndexOf('/'));
     for (Map.Entry<String, String> entry : inputMap.entrySet()) {
       String key = entry.getKey();
       if (key != null && key.endsWith(localName)) {
         return entry.getValue();
       }
     }
 
     //Fourth: look for exact localName match in current inputs
     for (String s : usedNames) {
       if (s.endsWith(localName)) {
         return s;
       }
     }
 
     return null;
   }
 
   /**
    * Find a name matching the specified one in the given candidates list.
    *
    * @param name The name to match
    * @return A match, or null
    */
   private String findOutputMatch(String name) {
     String[] usedNames = this.getUsedOutputNames();
 
     // Build inputs map
     Map<String, String> outputMap = new HashMap<String, String>();
     for (Map.Entry<QName, String> entry : this.getAttributes().entrySet()) {
       QName qname = entry.getKey();
       if (qname.getNamespaceURI().equals("output-map")) {
         outputMap.put(entry.getValue(), qname.getLocalPart());
       }
     }
 
     // First: look for exact match in mapped outputs
     if (outputMap.containsKey(name)) {
       return outputMap.get(name);
     }
 
     // Second: look for exact match in current outputs
     for (String s : usedNames) {
       if (s.equals(name)) {
         return s;
       }
     }
 
     // Third: look for exact localName match in the mapped outputs
     String localName = name.substring(name.lastIndexOf('/'));
     for (Map.Entry<String, String> entry : outputMap.entrySet()) {
       String key = entry.getKey();
       if (key != null && key.endsWith(localName)) {
         return entry.getValue();
       }
     }
 
     //Fourth: look for exact localName match in current outputs
     for (String s : usedNames) {
       if (s.endsWith(localName)) {
         return s;
       }
     }
 
     return null;
   }
 
   /**
    * {@inheritDoc}
    */
   @Override public Process copy() {
     AbstractProcessImpl copy = (AbstractProcessImpl)super.copy();
 
     if (this.candidates != null) {
       copy.candidates = new ArrayList<Process>();
       for (Process p : candidates) {
         copy.candidates.add(p.copy());
       }
     }
     copy.setSelected((selected == null) ? null : selected.copy());
 
     return copy;
   }
 }