/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.apache.commons.scxml2.env.javascript;
  
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  
  import javax.script.Bindings;
  import javax.script.SimpleBindings;
  
  import org.apache.commons.scxml2.Context;
  
  /**
   * Wrapper class for the JDK Javascript engine Bindings class that extends the
   * wrapped Bindings to search the SCXML context for variables and predefined
   * functions that do not exist in the wrapped Bindings.
   *
   */
  public class JSBindings implements Bindings {
  
      private static final String NASHORN_GLOBAL = "nashorn.global";
  
      // INSTANCE VARIABLES
  
      private Bindings bindings;
      private Context  context;
  
      // CONSTRUCTORS
  
      /**
       * Initialises the internal Bindings delegate and SCXML context.
       *
       * @param context  SCXML Context to use for script variables.
       * @param bindings Javascript engine bindings for Javascript variables.
       *
       * @throws IllegalArgumentException Thrown if either <code>context</code>
       *         or <code>bindings</code> is <code>null</code>.
       *
       */
      public JSBindings(Context context, Bindings bindings) {
          // ... validate
  
          if (context == null) {
             throw new IllegalArgumentException("Invalid SCXML context");
          }
  
          if (bindings == null) {
             throw new IllegalArgumentException("Invalid script Bindings");
          }
  
          // ... initialise
  
          this.bindings = bindings;
          this.context = context;
      }
  
      // INSTANCE METHODS
  
      /**
       * Returns <code>true</code> if the wrapped Bindings delegate
       * or SCXML context  contains a variable identified by
       * <code>key</code>.
       *
       */
      @Override
      public boolean containsKey(Object key) {
          if (hasGlobalBindings() && getGlobalBindings().containsKey(key)) {
              return true;
          }
  
          if (bindings.containsKey(key)) {
              return true;
          }
  
          return context.has(key.toString());
      }
  
      /**
       * Returns a union of the wrapped Bindings entry set and the
       * SCXML context entry set.
       * <p>
       * NOTE: doesn't seem to be invoked ever. Not thread-safe.
      *
      */
     @Override
     public Set<String> keySet() {
         Set<String> keys = new HashSet<String>();
 
         keys.addAll(context.getVars().keySet());
         keys.addAll(bindings.keySet());
 
         if (hasGlobalBindings()) {
             keys.addAll(getGlobalBindings().keySet());
         }
 
         return keys;
     }
 
     /**
      * Returns the combined size of the wrapped Bindings entry set and the
      * SCXML context entry set.
      * <p>
      * NOTE: doesn't seem to be invoked ever so not sure if it works in
      *       context. Not thread-safe.
      *
      */
     @Override
     public int size() {
         Set<String> keys = new HashSet<String>();
 
         keys.addAll(context.getVars().keySet());
         keys.addAll(bindings.keySet());
 
         if (hasGlobalBindings()) {
             keys.addAll(getGlobalBindings().keySet());
         }
 
         return keys.size();
     }
 
     /**
      * Returns <code>true</code> if the wrapped Bindings delegate
      * or SCXML context contains <code>value</code>.
      * <p>
      * NOTE: doesn't seem to be invoked ever so not sure if it works in
      *       context. Not thread-safe.
      */
     @Override
     public boolean containsValue(Object value) {
         if (hasGlobalBindings() && getGlobalBindings().containsValue(value)) {
             return true;
         }
 
         if (bindings.containsValue(value)) {
             return true;
         }
 
         return context.getVars().containsValue(value);
     }
 
     /**
      * Returns a union of the wrapped Bindings entry set and the
      * SCXML context entry set.
      * <p>
      * NOTE: doesn't seem to be invoked ever so not sure if it works in
      *       context. Not thread-safe.
      */
     @Override
     public Set<Map.Entry<String,Object>> entrySet() {
         return union().entrySet();
     }
 
     /**
      * Returns a union of the wrapped Bindings value list and the
      * SCXML context value list.
      * <p>
      * NOTE: doesn't seem to be invoked ever so not sure if it works in
      *       context. Not thread-safe.
      */
     @Override
     public Collection<Object> values() {
         return union().values();
     }
 
     /**
      * Returns a <code>true</code> if both the Bindings delegate and
      * the SCXML context maps are empty.
      * <p>
      * NOTE: doesn't seem to be invoked ever so not sure if it works in
      *       context. Not thread-safe.
      */
     @Override
     public boolean isEmpty() {
         if (hasGlobalBindings() && !getGlobalBindings().isEmpty()) {
             return false;
         }
 
         if (!bindings.isEmpty()) {
             return false;
         }
 
         return context.getVars().isEmpty();
     }
 
     /**
      * Returns the value from the wrapped Bindings delegate
      * or SCXML context contains identified by <code>key</code>.
      *
      */
     @Override
     public Object get(Object key) {
         // nashorn.global should be retrieved from the bindings, not from context.
         if (NASHORN_GLOBAL.equals(key)) {
             return bindings.get(key);
         }
 
         if (hasGlobalBindings() && getGlobalBindings().containsKey(key)) {
             return getGlobalBindings().get(key);
         }
 
         if (bindings.containsKey(key)) {
             return bindings.get(key);
         }
 
         return context.get(key.toString());
     }
 
     /**
      * The following delegation model is used to set values:
      * <ol>
      *   <li>Delegates to {@link Context#set(String,Object)} if the
      *       {@link Context} contains the key (name), else</li>
      *   <li>Delegates to the wrapped {@link Bindings#put(String, Object)}
      *       if the {@link Bindings} contains the key (name), else</li>
      *   <li>Delegates to {@link Context#setLocal(String, Object)}</li>
      * </ol>
      *
      */
     @Override
     public Object put(String name, Object value) {
         Object old = context.get(name);
 
         // nashorn.global should be put into the bindings, not into context.
         if (NASHORN_GLOBAL.equals(name)) {
             return bindings.put(name, value);
         } else if (context.has(name)) {
             context.set(name, value);
         } else if (bindings.containsKey(name)) {
             return bindings.put(name, value);
         } else if (hasGlobalBindings() && getGlobalBindings().containsKey(name)) {
             return getGlobalBindings().put(name, value);
         } else {
             context.setLocal(name, value);
         }
 
         return old;
     }
 
     /**
      * Delegates to the wrapped Bindings <code>putAll</code> method i.e. does
      * not store variables in the SCXML context.
      * <p>
      * NOTE: doesn't seem to be invoked ever so not sure if it works in
      *       context. Not thread-safe.
      */
     @Override
     public void putAll(Map<? extends String, ? extends Object> toMerge) {
         bindings.putAll(toMerge);
     }
 
     /**
      * Removes the object from the wrapped Bindings instance or the contained
      * SCXML context. Not entirely sure about this implementation but it
      * follows the philosophy of using the Javascript Bindings as a child context
      * of the SCXML context.
      * <p>
      * NOTE: doesn't seem to be invoked ever so not sure if it works in
      *       context. Not thread-safe.
      */
     @Override
     public Object remove(Object key) {
         if (hasGlobalBindings() && getGlobalBindings().containsKey(key)) {
             getGlobalBindings().remove(key);
         }
 
         if (bindings.containsKey(key)) {
             return bindings.remove(key);
         }
 
         if (context.has(key.toString())) {
             return context.getVars().remove(key);
         }
 
         return Boolean.FALSE;
     }
 
     /**
      * Delegates to the wrapped Bindings <code>clear</code> method. Does not clear
      * the SCXML context.
      * <p>
      * NOTE: doesn't seem to be invoked ever so not sure if it works in
      *       context. Not thread-safe.
      */
     @Override
     public void clear() {
         bindings.clear();
     }
 
     /**
      * Internal method to create a union of the SCXML context and the Javascript
      * Bindings. Does a heavyweight copy - and so far only invoked by the
      * not used methods.
      */
     private Bindings union() {
         Bindings set = new SimpleBindings();
 
         set.putAll(context.getVars());
 
         for (String key : bindings.keySet()) {
             set.put(key, bindings.get(key));
         }
 
         if (hasGlobalBindings()) {
             for (String key : getGlobalBindings().keySet()) {
                 set.put(key, getGlobalBindings().get(key));
             }
         }
 
         return set;
     }
 
     /**
      * Return true if a global bindings (i.e. nashorn Global instance) was ever set by the script engine.
      * <p>
      * Note: because the global binding can be set by the script engine when evaluating a script, we should
      *       check or retrieve the global binding whenever needed instead of initialization time.
      * </p>
      * @return true if a global bindings (i.e. nashorn Global instance) was ever set by the script engine
      */
     protected boolean hasGlobalBindings() {
         if (bindings.containsKey(NASHORN_GLOBAL)) {
             return true;
         }
 
         return false;
     }
 
     /**
      * Return the global bindings (i.e. nashorn Global instance) set by the script engine if existing.
      * @return the global bindings (i.e. nashorn Global instance) set by the script engine, or null if not existing.
      */
     protected Bindings getGlobalBindings() {
         if (bindings.containsKey(NASHORN_GLOBAL)) {
             return (Bindings) bindings.get(NASHORN_GLOBAL);
         }
 
         return null;
     }
 }