/*
    WSMO Studio - a Semantic Web Service Editor
    Copyright (c) 2004-2007, Ontotext Lab. / SIRMA Group
    
    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.,
   59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
   */
  
  /***
   * <p>Title: WSMO Studio</p>
   * <p>Description: Semantic Web Service Editor</p>
   * <p>Copyright:  Copyright (c) 2004-2007</p>
   * <p>Company: Ontotext Lab. / SIRMA </p>
   */
  
  package org.wsmostudio.bpmo.model;
  
  import java.util.*;
  
  import org.eclipse.draw2d.geometry.Dimension;
  import org.eclipse.draw2d.geometry.Point;
  import org.omwg.ontology.Ontology;
  import org.wsmo.common.Namespace;
  import org.wsmo.common.TopEntity;
  import org.wsmostudio.bpmo.ui.editor.BpmoEditor;
  import org.wsmostudio.runtime.WSMORuntime;
  
  import com.ontotext.sbpm.bpmo.common.Constants;
  
  public class BpmoModel extends WorkflowEntitiesContainer {
  
      private List<ProcessNode> processes;
      private BpmoEditor editorPart = null;
      private Ontology nsHolder = null;
      
  	public BpmoModel() {
  		this.processes = new ArrayList<ProcessNode>();
  	}
  	
  	public void setContainingEditor(BpmoEditor editor) {
  		this.editorPart = editor;
  	}
  	
  	public void notifyContentChanged() {
  		if (this.editorPart != null) {
  		    this.editorPart.markDirty();
  		}
  	}
  	
  	public List<ProcessNode> listProcesses() {
  		return Collections.unmodifiableList(this.processes);
  	}
      
      public void addProcess(ProcessNode process) {
          this.processes.add(process);
          if (process.getOwner() != this) {
              process.setOwner(this);
          }
          firePropertyChange("content", null, process);
      }
  
      public void removeProcess(ProcessNode process) {
          this.processes.remove(process);
          process.setOwner(null);
          firePropertyChange("content", process, null);
      }
      
      public Dimension getPreferredSize() {
          return null; // not really needed
      }
  
      @Override
      public WorkflowEntityNode cloneNode() {
          throw new UnsupportedOperationException();
      }
      
      public List<WorkflowProperty> listSupportedProperties() {
          return new LinkedList<WorkflowProperty>();
      }
  
      public TopEntity getNSHolder() {
          return this.nsHolder;
      }
      
      public void setNamespaces(Ontology onto) {
          this.nsHolder = onto;
      }
  
      public void updateNamespacesTo(Ontology onto) {
          if (this.nsHolder == null) {
             return;
         }
         if (this.nsHolder.getDefaultNamespace() != null) {
             onto.setDefaultNamespace(this.nsHolder.getDefaultNamespace());
         }
         else {
             onto.setDefaultNamespace(
                     WSMORuntime.getRuntime().getWsmoFactory().createIRI(
                             Constants.DEFAULT_NS));
         }
         for(Namespace ns : this.nsHolder.listNamespaces()) {
             boolean isUnique = true;
             for(Namespace existing : onto.listNamespaces()) {
                 if (existing.getIRI().equals(ns.getIRI())) {
                     isUnique = false;
                     break;
                 }
             }
             if (isUnique) {
                 onto.addNamespace(ns); // add only the new ones and preserve any existing
             }
         }
     }
     
     public void reorderProcessNodes() {
         if (processes.size() < 2) {
             return;
         }
         ProcessNode[] childNodes = 
             processes.toArray(new ProcessNode[processes.size()]);
         Arrays.sort(childNodes, new Comparator<ProcessNode>() {
             public int compare(ProcessNode o1, ProcessNode o2) {
                 return o1.getLocation().y - o2.getLocation().y;
             }
         });
         int nextAvailableY = 10;
         for(int i = 0; i < childNodes.length; i++) {
             ProcessNode prevNode = (i == 0) ? childNodes[i] : childNodes[i-1];
             shiftNodesAfter(i, childNodes, nextAvailableY, prevNode.getLocation().x, prevNode.getSize().width);
             nextAvailableY = 
                 childNodes[i].getLocation().y + childNodes[i].getSize().height + 10;
         }
     }
 
     private void shiftNodesAfter(int index, ProcessNode[] all, int minY, int prevX, int prevW) {
         for(int i = index; i < all.length; i++) {
             Point loc = all[i].getLocation();
             if (loc.y < minY) {
                 boolean mustMove = i == 0;
                 if (i > 0) {
                     mustMove = (prevX + prevW > loc.x - 5 
                             && prevX < loc.x + all[i].getSize().width + 5); 
                 }
                 if (mustMove) {
                     all[i].moveToLocation(loc.x, minY);
                 }
             }
         }
     }
 
     
 }
 
 /*
  * $Log$
  * Revision 1.4  2007/08/01 15:47:23  alex_simov
  * ui model refactoring: classnames are suffixed by "Node" to avoid name
  * clashes with BPMO-API entities
  *
  * Revision 1.3  2007/06/26 17:44:31  alex_simov
  * integrated composer
  *
  * Revision 1.2  2007/04/05 16:50:34  alex_simov
  * loop block patterns added
  *
  * Revision 1.1  2007/03/20 10:05:46  alex_simov
  * SBP modeller initial version
  *
  */