/*
    * Copyright 2010 Fraunhofer Gesellschaft, Munich, Germany,
    * for its Fraunhofer Institute for Computer Architecture and Software
    * Technology (FIRST), Berlin, Germany. All rights reserved.
    * http://www.first.fraunhofer.de/
    */
   
   package net.kwfgrid.gwes;
   
  import net.kwfgrid.gworkflowdl.structure.*;
  import net.kwfgrid.gwes.util.StringUtils;
  
  import java.util.ArrayList;
  
  /**
   * @author Andreas Hoheisel
   *         (<a href="http://www.andreas-hoheisel.de">www.andreas-hoheisel.de</a>)
   * @version $Id: TokenUtils.java 1433 2010-11-29 18:06:07Z hoheisel $
   */
  public class TokenUtils {
  
      private static TokenUtils _instance;
      public final static int DATA_GROUP_IGNORE_READ_WRITE = 1;
      public final static int DATA_GROUP_IGNORE_CONTROL = 2;
  
      private TokenUtils() {
          // private constructor because of singleton pattern.
      }
  
      /**
       * Singleton pattern
       */
      public static TokenUtils getInstance() {
          if (_instance == null) {
              _instance = new TokenUtils();
          }
          return _instance;
      }
  
      /**
       * Search next token of a certain dataGroup which is not locked.
       *
       * @param edge
       * @return The next unlocked token or <code>null</code> if there is no unlocked token.
       */
      public static Token getNextUnlockedToken(Edge edge, boolean isReadEdge, String dataGroup, int ignoreDataGroups) {
          for (Token token : edge.getPlace().getTokens()) {
              if (!token.isLocked() && checkDataGroup(token, isReadEdge, dataGroup, ignoreDataGroups)) {
                  return token;
              }
          }
          return null;
      }
  
      /**
       * Get the index of the next token of a certain dataGroup which is not locked
       * @param edge
       * @param dataGroup
       * @return The index of the next unlocked token or <code>-1</code> if there is no unlocked token.
       */
      public static int getNextUnlockedTokenIndex(Edge edge, boolean isReadEdge, String dataGroup, int ignoreDataGroups) {
          Token[] tokens = edge.getPlace().getTokens();
          for (int i = 0; i<tokens.length; i++) {
              if (!tokens[i].isLocked() && checkDataGroup(tokens[i], isReadEdge, dataGroup, ignoreDataGroups)) {
                  return i;
              }
          }
          return -1;
      }
  
      /**
       * Check if the token belongs to a certain data group.
       *
       * @param token
       * @param dataGroup
       * @return "true" iff the dataGroup is null or if there is no data.group property or if the data.group property
       *         equals the dataGroup string.
       */
      public static boolean checkDataGroup(Token token, boolean isReadWriteToken, String dataGroup, int ignoreDataGroup) {
          if (dataGroup == null) return true;
          if ( ((ignoreDataGroup& DATA_GROUP_IGNORE_READ_WRITE)!=0) && isReadWriteToken) return true;
          if ( ((ignoreDataGroup&DATA_GROUP_IGNORE_CONTROL)!=0) && token.getData() == null) return true;
          String tDataGroup = token.getProperties().get(Constants.PROP_TOKEN_DATA_GROUP);
          return tDataGroup == null || tDataGroup.equals(dataGroup);
      }
  
      public static String updateDataGroup(TokenParameter tp, int ignoreDataGroups, String[] combineDataGroupsEdgeExpressions, ArrayList<String> dataGroups) {
          // check if read or write token which should be ignored
          if (((ignoreDataGroups& DATA_GROUP_IGNORE_READ_WRITE)!=0) && (tp.scope==TokenParameter.Scope.READ || tp.scope == TokenParameter.Scope.WRITE) ) return null;
          // check if control token which should be ignored
          if ( ((ignoreDataGroups&DATA_GROUP_IGNORE_CONTROL)!=0) && tp.token.getData() == null) return null;
  
          String dataGroup = null;
          String tokenDataGroup = tp.token.getProperties().get(Constants.PROP_TOKEN_DATA_GROUP);
  
          if (combineDataGroupsEdgeExpressions != null) {
              // combine data groups
              for (String edgeExpression : combineDataGroupsEdgeExpressions) {
                  if (edgeExpression.equals(tp.edge.getExpression())) {
                     dataGroups.add(tokenDataGroup);
                     return null;
                 }
             }
         } else {
             // single data group
             dataGroup = tokenDataGroup;
         }
         return dataGroup;
     }
 
     public static int getIgnoreDataGroupsCode(Transition transition) {
         String str = transition.getProperties().get(Constants.PROP_TRANSITION_IGNORE_DATA_GROUPS);
         if (str == null) return 0;
         int code = 0;
         if (str.contains("read") || str.contains("write")) code += DATA_GROUP_IGNORE_READ_WRITE;
         if (str.contains("control")) code +=DATA_GROUP_IGNORE_CONTROL;
         return code;
     }
 
     public static String[] getCombineDataGroupsEdgeExpressions(Transition transition) {
         String str = transition.getProperties().get(Constants.PROP_TRANSITION_COMBINE_DATA_GROUPS);
         if (str == null) return null;
         return StringUtils.splitSpacesAndMore(str);
     }
 
 }