/*
    WSMO Studio - a Semantic Web Service Editor
    Copyright (c) 2004-2006, 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-2006</p>
   * <p>Company: OntoText Lab. / SIRMA </p>
   */
  
  package org.wsmostudio.choreography.editors;
  
  import java.util.*;
  
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.events.*;
  import org.eclipse.swt.layout.*;
  import org.eclipse.swt.widgets.*;
  import org.omwg.ontology.Variable;
  import org.wsmo.factory.LogicalExpressionFactory;
  import org.wsmo.service.choreography.rule.*;
  import org.wsmo.service.rule.ChoreographyRule;
  import org.wsmo.service.rule.Condition;
  import org.wsmostudio.choreography.ChoreographyPlugin;
  import org.wsmostudio.choreography.editors.model.ChoreographyModel;
  import org.wsmostudio.runtime.WSMORuntime;
  import org.wsmostudio.ui.Utils;
  
  public class QuantRuleEditor extends RuleFormEditor {
  
      private Text exprContainer;
      private Text varsContainer;
      
      private boolean dirty = false;
  
  
      public QuantRuleEditor(ChoreographyRule rule, ChoreographyModel model) {
          super(rule, model);
      }
      
      public Composite initUI(Composite parent) {
          Composite mainContainer = new Composite(parent, SWT.BORDER);
          mainContainer.setLayoutData(new GridData(GridData.FILL_BOTH));
          mainContainer.setLayout(new GridLayout(1, false));
          Composite header = new Composite(mainContainer, SWT.NONE);
          header.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
          header.setLayout(new GridLayout(2, false));
          
          new Label(header, SWT.NONE).setImage(RulesManagementPanel.iconForRule(rule));
          Label lab = new Label(header, SWT.NONE);
          lab.setText(labelForRule());
          lab.setForeground(
                  parent.getDisplay().getSystemColor(SWT.COLOR_BLUE));
          lab.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
          
          new Label(mainContainer, SWT.NONE).setText("Variable(s) :");
  
          varsContainer = new Text(mainContainer, SWT.BORDER | SWT.SINGLE);
          varsContainer.setText(
                  RulesManagementPanel.varsAsString(((ChoreographyQuantifiedRule)rule).listVariables()));
          varsContainer.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
          varsContainer.addModifyListener(new ModifyListener() {
              public void modifyText(ModifyEvent me) {
                  uiModel.setChanged();
                  dirty = true;
              }
          });
  
          new Label(mainContainer, SWT.NONE).setText("Condition :");
          
          exprContainer = new Text(mainContainer, 
                  SWT.BORDER | SWT.MULTI | SWT.V_SCROLL | SWT.WRAP);
          exprContainer.setText(
                  ((ChoreographyQuantifiedRule)rule).getCondition().getRestrictedLogicalExpression().toString(
                          Utils.findTopContainer(uiModel)));
          exprContainer.setLayoutData(new GridData(GridData.FILL_BOTH));
          exprContainer.addModifyListener(new ModifyListener() {
              public void modifyText(ModifyEvent me) {
                  uiModel.setChanged();
                  dirty = true;
              }
          });
  
          return mainContainer;
      }
 
     public void updateRule() throws Exception {
         if (dirty == false) {
             return; // no update is needed
         }
         String newConditionText = exprContainer.getText().trim();
         ChoreographyQuantifiedRule theRule = (ChoreographyQuantifiedRule)getRule();
         boolean varsChange = updateVars(theRule);
         if (theRule.getCondition() != null 
                 && theRule.getCondition().toString().trim().equals(newConditionText)
                 && false == varsChange) {
             return; // no change
         }
         
         LogicalExpressionFactory leFactory = WSMORuntime.getRuntime().getLogExprFactory();
         Condition condition = 
             ChoreographyPlugin.getFactory().transitionRules.createConditionFromLogicalExpression(
                     leFactory.createLogicalExpression(newConditionText,
                             Utils.findTopContainer(uiModel)));
         
         theRule.setCondition(condition);
     }
     
     private boolean updateVars(ChoreographyQuantifiedRule rule) throws Exception {
         Set<String> newVars = new HashSet<String>();
         boolean modified = false;
         
         // parsing the input string
         StringTokenizer toker = new StringTokenizer(varsContainer.getText()," ,?"); 
         while (toker.hasMoreTokens()) {
             String varName = toker.nextToken();
             for (int i = 0; i < varName.length(); i++ ) {
                 if (false == Character.isLetterOrDigit(varName.charAt(i))) {
                     throw new Exception("Invalid character '" 
                             + varName.charAt(i) 
                             + "' in variable '"
                             + varName
                             + "'!");
                 }
             }
             newVars.add(varName);
         }
         // comparing with the rule's variables
         Set<Variable> oldOnes = new HashSet<Variable>(rule.listVariables());
         for(Iterator<Variable> it = oldOnes.iterator(); it.hasNext();) {
             Variable varObj = it.next();
             if (newVars.contains(varObj.getName())) {
                 newVars.remove(varObj.getName());
             }
             else {
                 rule.removeVariable(varObj);
                 modified = true;
             }
         }
         // adding the new vars:
         for(Iterator it = newVars.iterator(); it.hasNext();) {
             Variable newVar = WSMORuntime.getRuntime().getLogExprFactory().createVariable((String)it.next());
             rule.addVariable(newVar);
             modified = true;
         }
         return modified;
     }
     
     @Override
     public void dispose() {
         varsContainer.dispose();
         exprContainer.dispose();
     }
 
 }
 
 /*
  * $Log$
  * Revision 1.12  2006/11/22 14:11:06  alex_simov
  * Code refactoring: the plug-in is synchronized with the latest wsmo4j changes
  *
  * Revision 1.11  2006/06/22 13:21:06  vassil_momtchev
  * method WsmoFactory.createVariable(String) moved to LogicalExpressionFactory.createVariable(String)
  *
  * Revision 1.10  2006/04/18 07:14:37  alex_simov
  * Adapting to the recent choreography-api changes
  *
  * Revision 1.9  2006/02/17 09:49:12  alex_simov
  * new variables input string not parsed precisely enough
  *
  * Revision 1.8  2006/02/16 13:41:27  alex_simov
  * bugfix [1426200]: namespace definitions were not used in choreography rule
  *  editors
  *
  * Revision 1.7  2006/02/14 15:07:52  alex_simov
  * bugfix[1431322]: quantified variables lost during rule updating
  *
  * Revision 1.6  2006/01/09 12:51:11  alex_simov
  * Copyright message in header updated
  *
  * Revision 1.5  2005/12/21 15:25:35  alex_simov
  * choreography managment implementation completed
  *
  * Revision 1.4  2005/12/19 15:35:54  alex_simov
  * update
  *
  * Revision 1.3  2005/11/24 13:48:16  alex_simov
  * logical expression field contains now wrapped text
  * (instead of horizontal scroll bar)
  * [bug issue 1365441]
  *
  */