package cz.cuni.amis.pogamut.sposh.engine;
   
   import cz.cuni.amis.pogamut.sposh.elements.Arguments;
   import cz.cuni.amis.pogamut.sposh.elements.Arguments.Argument;
   import cz.cuni.amis.pogamut.sposh.elements.FormalParameters;
   import java.util.Arrays;
   import java.util.HashMap;
   import java.util.Map;
   import java.util.Map.Entry;
  
  /**
   * This class is responsible for storing and passing arguments throught the posh plan.
   * Unnamed varibales are named as number (e.g. "0", "1"...), named variables
   * have same name as in plan.
   * @author Honza
   */
  final public class VariableContext {
  
      private Map<String, Object> args = new HashMap<String, Object>();
  
      public VariableContext() {
      }
  
      /**
       * Create argument context from formal parameters.
       */
      VariableContext(FormalParameters params) {
          for (FormalParameters.Parameter param : params) {
              if (args.put(param.getName(), param.getDefaultValue()) != null) {
                  throw new IllegalArgumentException(
                          "Two parameters with same name \"" + param.getName()
                          + "\", default value \"" + param.getDefaultValue() + "\".");
              }
          }
      }
  
      /**
       * Create new VariableContext that will contain only variables from call arguments.
       * @param callArgs
       */
      VariableContext(VariableContext ctx, Arguments callArgs) {
          for (Arguments.Argument param : callArgs) {
              String argumentVariable = param.getParameterVariable();
              if (argumentVariable != null) {
                  args.put(param.getParameterName(), ctx.getValue(argumentVariable));
              } else {
                  args.put(param.getParameterName(), param.getValue());
              }
          }
      }
  
      VariableContext(VariableContext ctx) {
          for (Map.Entry<String, Object> arg : ctx.args.entrySet()) {
              args.put(arg.getKey(), arg.getValue());
          }
      }
  
      /**
       * Create new variable context for diving into another function.
       * New context will contain only variables from formal parameters, and its
       * values will be values passed from call arguments or (if missing) default value
       * from formal parametrs.
       * 
       * @param ctx
       * @param callParameters
       * @param formalParameters
       */
      VariableContext(VariableContext ctx, Arguments callParameters, FormalParameters formalParameters) {
          for (int index = 0; index < formalParameters.size(); ++index) {
              String ctxVariableName = formalParameters.get(index).getName();
              Object ctxVariableValue = formalParameters.get(index).getDefaultValue();
  
              // if user supplied value, get it and put it into ctxVariableValue instead of default value
              for (Argument param : callParameters) {
                  String argumentName = param.getParameterName();
                  try {
                      int paramterIndex = Integer.parseInt(argumentName);
                      if (index != paramterIndex) {
                          continue;
                      }
                  } catch (NumberFormatException ex) {
                      // nope, this is not a unnamed parametr, this one has a name
                      // Is name among formal parametrs?
                      String parameterName = param.getParameterName();
                      if (!parameterName.equals(ctxVariableName))
                          continue;
                  }
                  
                  String variableName = param.getParameterVariable();
                  if (variableName != null) {
                      ctxVariableValue = ctx.getValue(variableName);
                  } else {
                      ctxVariableValue = param.getValue();
                  }
              }
  
              args.put(ctxVariableName, ctxVariableValue);
          }
      }
 
     /**
      * Put another variable into this context
      * @param parameterName name of new parameter
      * @param value value of parameter
      * @return old value for parameterName or null if it is a new parameter.
      */
     public synchronized Object put(String parameterName, Object value) {
         return args.put(parameterName, value);
     }
 
     /**
      * Get keys of all variables in this context.
      * @return
      */
     public synchronized String[] getKeys() {
         return args.keySet().toArray(new String[args.size()]);
     }
 
     /**
      * Get value stored in the 
      * @param variableName
      * @return
      */
     public synchronized Object getValue(String variableName) {
         if (args.containsKey(variableName)) {
             return args.get(variableName);
         }
         throw new IllegalArgumentException("There is no variable in the context with name \"" + variableName + "\".");
     }
 
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
 
         sb.append('[');
         String[] list = new String[args.size()];
         int index = 0;
         for (Entry entry : args.entrySet()) {
             list[index++] = entry.getKey() + "=" + entry.getValue();
         }
         Arrays.sort(list);
         for (int i = 0; i < list.length; ++i) {
             if (i != 0) {
                 sb.append(", ");
             }
             sb.append(list[i]);
         }
 
         sb.append(']');
         return sb.toString();
     }
 
     public synchronized int size() {
         return this.args.size();
     }
 }