tobago-core/src/main/java/org/apache/myfaces/tobago/internal/behavior/EventBehavior.java

/*
 * 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.myfaces.tobago.internal.behavior;

import javax.el.ValueExpression;
import javax.faces.component.StateHelper;
import javax.faces.component.behavior.ClientBehaviorBase;
import javax.faces.component.behavior.ClientBehaviorHint;
import javax.faces.component.behavior.FacesBehavior;
import javax.faces.context.FacesContext;
import javax.faces.event.AjaxBehaviorListener;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumSet;
import java.util.Map;
import java.util.Set;

// todo: clean up (is a copy of MyFaces, but not all stuff is refactored)

/**
 * @since 3.0.0
 */
@FacesBehavior(value = EventBehavior.BEHAVIOR_ID)
public class EventBehavior extends ClientBehaviorBase {

  /**
   * not needed anymore but enforced by the spec
   * theoretically a
   *
   * FacesBehavior(value = "javax.faces.behavior.Ajax")
   * could do it
   */
  public static final String BEHAVIOR_ID = "org.apache.myfaces.tobago.behavior.Event";

  private static final String ATTR_EXECUTE = "execute";
  private static final String ATTR_ON_ERROR = "onerror";
  private static final String ATTR_ON_EVENT = "onevent";
  private static final String ATTR_RENDER = "render";
  private static final String ATTR_DISABLED = "disabled";
  private static final String ATTR_IMMEDIATE = "immediate";
  private static final String ATTR_FOR = "for";

  /**
   * special render and execute targets
   */
  private static final String VAL_FORM = "@form";
  private static final String VAL_ALL = "@all";
  private static final String VAL_THIS = "@this";
  private static final String VAL_NONE = "@none";

  private static final Collection<String> VAL_FORM_LIST = Collections.singletonList(VAL_FORM);
  private static final Collection<String> VAL_ALL_LIST = Collections.singletonList(VAL_ALL);
  private static final Collection<String> VAL_THIS_LIST = Collections.singletonList(VAL_THIS);
  private static final Collection<String> VAL_NONE_LIST = Collections.singletonList(VAL_NONE);

  //To enable delta state saving we need this one
  private DeltaStateHelper<EventBehavior> stateHelper = null;

  //private Map<String, ValueExpression> _valueExpressions
  //        = new HashMap<String, ValueExpression>();

  public EventBehavior() {
    super();
  }

  public void addAjaxBehaviorListener(final AjaxBehaviorListener listener) {
    super.addBehaviorListener(listener);
  }

  public void removeAjaxBehaviorListener(final AjaxBehaviorListener listener) {
    removeBehaviorListener(listener);
  }

  public Collection<String> getExecute() {
    // we have to evaluate the real value in this method,
    // because the value of the ValueExpression might
    // change (almost sure it does!)
    return evalForCollection(ATTR_EXECUTE);
  }

  public void setExecute(final Collection<String> execute) {
    getStateHelper().put(ATTR_EXECUTE, execute);
  }

  public String getOnerror() {
    return (String) getStateHelper().eval(ATTR_ON_ERROR);
  }

  public void setOnerror(final String onError) {
    getStateHelper().put(ATTR_ON_ERROR, onError);
  }

  public String getOnevent() {
    return (String) getStateHelper().eval(ATTR_ON_EVENT);
  }

  public void setOnevent(final String onEvent) {
    getStateHelper().put(ATTR_ON_EVENT, onEvent);
  }

  public Collection<String> getRender() {
    // we have to evaluate the real value in this method,
    // because the value of the ValueExpression might
    // change (almost sure it does!)
    return evalForCollection(ATTR_RENDER);
  }

  public void setRender(final Collection<String> render) {
    getStateHelper().put(ATTR_RENDER, render);
  }

  @SuppressWarnings("unchecked")
  public ValueExpression getValueExpression(final String name) {
    //return getValueExpressionMap().get(name);
    if (name == null) {
      throw new NullPointerException("name can not be null");
    }

    final Map<String, Object> bindings = (Map<String, Object>) getStateHelper().
        get(EventBehavior.PropertyKeys.bindings);
    if (bindings != null) {
      return (ValueExpression) bindings.get(name);
    } else {
      return null;
    }
  }

  public void setValueExpression(final String name, final ValueExpression expression) {
        /*
        if (item == null)
        {
            getValueExpressionMap().remove(name);
            getStateHelper().remove(name);
        }
        else
        {
            getValueExpressionMap().put(name, item);
        }
        */
    if (name == null) {
      throw new NullPointerException("name");
    }

    if (expression == null) {
      getStateHelper().remove(EventBehavior.PropertyKeys.bindings, name);
    } else {
      getStateHelper().put(EventBehavior.PropertyKeys.bindings, name, expression);
    }
  }

  public boolean isDisabled() {
    Boolean retVal = (Boolean) getStateHelper().eval(ATTR_DISABLED);
    retVal = (retVal == null) ? false : retVal;
    return retVal;
  }

  public void setDisabled(final boolean disabled) {
    getStateHelper().put(ATTR_DISABLED, disabled);
  }

  public boolean isImmediate() {
    Boolean retVal = (Boolean) getStateHelper().eval(ATTR_IMMEDIATE);
    retVal = (retVal == null) ? false : retVal;
    return retVal;
  }

  public void setImmediate(final boolean immediate) {
    getStateHelper().put(ATTR_IMMEDIATE, immediate);
  }

  public boolean isImmediateSet() {
    return (getStateHelper().get(ATTR_IMMEDIATE) != null) || (getValueExpression(ATTR_IMMEDIATE) != null);
  }

  public String getFor() {
    return (String) getStateHelper().eval(ATTR_FOR);
  }

  public void setFor(final String id) {
    getStateHelper().put(ATTR_FOR, id);
  }

  @Override
  public Set<ClientBehaviorHint> getHints() {
    return EnumSet.of(ClientBehaviorHint.SUBMITTING);
  }

  @Override
  public String getRendererType() {
    return BEHAVIOR_ID;
  }

  @Override
  public void restoreState(final FacesContext facesContext, final Object o) {
    if (o == null) {
      return;
    }
    final Object[] values = (Object[]) o;
    if (values[0] != null) {
      super.restoreState(facesContext, values[0]);
    }
    getStateHelper().restoreState(facesContext, values[1]);
  }

  private StateHelper getStateHelper() {
    return getStateHelper(true);
  }

  /**
   * returns a delta state saving enabled state helper
   * for the current component
   *
   * @param create if true a state helper is created if not already existing
   * @return an implementation of the StateHelper interface or null if none exists and create is set to false
   */
  private StateHelper getStateHelper(final boolean create) {
    if (stateHelper != null) {
      return stateHelper;
    }
    if (create) {
      stateHelper = new DeltaStateHelper<>(this);
    }
    return stateHelper;
  }

  @Override
  public Object saveState(final FacesContext facesContext) {
    if (initialStateMarked()) {
      final Object parentSaved = super.saveState(facesContext);
      Object stateHelperSaved = null;
      final StateHelper myStateHelper = getStateHelper(false);
      if (myStateHelper != null) {
        stateHelperSaved = myStateHelper.saveState(facesContext);
      }

      if (parentSaved == null && stateHelperSaved == null) {
        //No values
        return null;
      }
      return new Object[]{parentSaved, stateHelperSaved};
    } else {
      final Object[] values = new Object[2];
      values[0] = super.saveState(facesContext);
      final StateHelper myStateHelper = getStateHelper(false);
      if (myStateHelper != null) {
        values[1] = myStateHelper.saveState(facesContext);
      }
      return values;
    }
  }

  //private Map<String, ValueExpression> getValueExpressionMap()
  //{
  //    return _valueExpressions;
  //}

  /**
   * Invokes eval on the getStateHelper() and tries to get a
   * Collection out of the result.
   */
  @SuppressWarnings("unchecked")
  private Collection<String> evalForCollection(final String attributeName) {
    final Object value = getStateHelper().eval(attributeName);
    if (value == null) {
      return Collections.emptyList();
    } else if (value instanceof Collection) {
      return (Collection<String>) value;
    } else if (value instanceof String) {
      return getCollectionFromSpaceSplitString((String) value);
    } else {
      throw new IllegalArgumentException("Type " + value.getClass()
          + " not supported for attribute " + attributeName);
    }
  }

  /**
   * Splits the String based on spaces and returns the
   * resulting Strings as Collection.
   */
  private Collection<String> getCollectionFromSpaceSplitString(final String stringValue) {
    //@special handling for @all, @none, @form and @this
    if (stringValue.equals(VAL_FORM)) {
      return VAL_FORM_LIST;
    } else if (stringValue.equals(VAL_ALL)) {
      return VAL_ALL_LIST;
    } else if (stringValue.equals(VAL_NONE)) {
      return VAL_NONE_LIST;
    } else if (stringValue.equals(VAL_THIS)) {
      return VAL_THIS_LIST;
    }

    // not one of the "normal" values - split it and return the Collection
    final String[] arrValue = stringValue.split(" ");
    return Arrays.asList(arrValue);
  }

  private enum PropertyKeys {
    bindings,
  }
}