/*
 * 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.StateHolder;
import javax.faces.component.UIComponentBase;
import javax.faces.context.FacesContext;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

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

/**
 * A delta enabled state holder implementing the StateHolder Interface.
 * <p>
 * Components implementing the PartalStateHolder interface have an initial state
 * and delta states, the initial state is the one holding all root values
 * and deltas store differences to the initial states
 * </p>
 * <p>
 * For components not implementing partial state saving only the initial states are
 * of importance, everything is stored and restored continously there
 * </p>
 * <p>
 * The state helper seems to have three internal storage mechanisms:
 * one being a list which stores plain values,
 * one being a key value pair which stores key values in maps
 * add serves the plain list type while put serves the
 * key value type,
 * the third is the value which has to be stored plainly as is!
 * </p>
 * In other words, this map can be seen as a composite map. It has two maps:
 * initial state map and delta map.
 * <p>
 * If delta map is used (method component.initialStateMarked() ),
 * base or initial state map cannot be changed, since all changes
 * should be tracked on delta map.
 * </p>
 * <p>
 * The intention of this class is just hold property values
 * and do a clean separation between initial state and delta.
 * </p>
 * <p>
 * The code from this class comes from a refactor of
 * org.apache.myfaces.trinidad.bean.util.PropertyHashMap
 * </p>
 * <p>
 * The context from this class comes and that should be taken into account
 * is this:
 * </p>
 * <p>
 * First request:
 * </p>
 * <ul>
 * <li> A new template is created (using
 * javax.faces.view.ViewDeclarationLanguage.buildView method)
 * and component.markInitialState is called from its related TagHandler classes
 * (see javax.faces.view.facelets.ComponentHandler ).
 * When this method is executed, the component tree was populated from the values
 * set in the facelet abstract syntax tree (or in other words composition of
 * facelets templates). </li>
 * <li> From this point all updates on the variables are considered "delta". </li>
 * <li> SaveState, if initialStateMarked is true, only delta is saved. </li>
 * </ul>
 * <p>
 * Second request (and next ones)
 * </p>
 * <ul>
 * <li> A new template is created and component.markInitialState is called from
 * its related TagHandler classes again. In this way, components like c:forEach
 * or c:if, that add or remove components could notify about this and handle
 * them properly (see javax.faces.view.StateManagementStrategy). Note that a
 * component restored using this method is no different as the same component
 * at the first request at the same time. </li>
 * <li> A call for restoreState is done, passing the delta as object value. If no
 * delta, the state is complete and no call is triggered. </li>
 * <li> Lifecycle occur, changing the necessary stuff. </li>
 * <li> SaveState, if initialStateMarked is true, only delta is saved. </li>
 * </ul>
 * <p>
 * From the previous analysis, the following conclusions arise:
 * <ul>
 * <li>This class only needs to keep track of delta changes, so when
 * restoreState/saveState is called, the right objects are passed.</li>
 * <li>UIComponent.clearInitialState is used to reset the partial
 * state holder to a non delta state, so the state to be saved by
 * saveState is no longer a delta instead is a full state. If a call
 * to clearInitialState occur it is not expected a call for
 * UIComponent.markInitialState occur on the current request.</li>
 * <li>The state is handled in the same way on UIData, so components
 * inside UIData share its state on all rows. There is no way to save
 * delta per row.</li>
 * <li>The map backed by method put(Serializable,String,Object) is
 * a replacement of UIComponentBase.attributesMap and UIComponent.bindings map.
 * Note that on jsf 1.2, instances saved on attributesMap should not be
 * StateHolder, but on jsf 2.0 it is possible to have it. PartialStateHolder
 * instances are not handled in this map, or in other words delta state is not
 * handled in this classes (markInitialState and clearInitialState is not propagated).</li>
 * <li>The list backed by method add(Serializable,Object) should be (is not) a
 * replacement of UIComponentBase.facesListeners, but note that StateHelper
 * does not implement PartialStateHolder, and facesListener could have instances
 * of that class that needs to be notified when UIComponent.markInitialState or
 * UIComponent.clearInitialState is called, or in other words facesListeners
 * should deal with PartialStateHolder instances.</li>
 * <li>The list backed by method add(Serializable,Object) is
 * a replacement of UIViewRoot.phaseListeners list. Note that instances of
 * PhaseListener are not expected to implement StateHolder or PartialStateHolder.</li>
 * </ul>
 * </p>
 * <p>
 * NOTE: The current implementation of StateHelper on RI does not handle
 * stateHolder values internally. To prevent problems when developers create
 * custom components we should do this too. But anyway, the code that
 * handle this case should be let here as comment, if some day this feature
 * is provided. Note than stateHolder aware properties like converter,
 * validator or listeners should deal with StateHolder or PartialStateHolder
 * on component classes.
 * <p>
 * </p>
 *
 * @since 3.0.0
 */
class DeltaStateHelper<A extends EventBehavior> implements StateHelper {

  /**
   * We need to hold a component instance because:
   * <p>
   * - The component is the one who knows if we are on initial or delta mode
   * - eval assume calls to component.ValueExpression
   */
  private A target;

  /**
   * This map holds the full current state
   */
  private Map<Serializable, Object> fullState;

  /**
   * This map only keep track of delta changes to be saved
   */
  private Map<Serializable, Object> deltas;

  /**
   * This map keep track of StateHolder keys, to be saved when
   * saveState is called.
   */
  //private Set<Serializable> _stateHolderKeys;

  private boolean transientBoolean = false;

  public DeltaStateHelper(A target) {
    super();
    this.target = target;
    fullState = new HashMap<Serializable, Object>();
    deltas = null;
    //_stateHolderKeys = new HashSet<Serializable>();
  }

  /**
   * Used to create delta map on demand
   *
   * @return
   */
  private boolean createDeltas() {
    if (isInitialStateMarked()) {
      if (deltas == null) {
        deltas = new HashMap<Serializable, Object>(2);
      }
      return true;
    }

    return false;
  }

  protected boolean isInitialStateMarked() {
    return target.initialStateMarked();
  }

  public void add(Serializable key, Object value) {
    if (createDeltas()) {
      //Track delta case
      Map<Object, Boolean> deltaListMapValues = (Map<Object, Boolean>) deltas
          .get(key);
      if (deltaListMapValues == null) {
        deltaListMapValues = new DeltaStateHelper.InternalDeltaListMap<Object, Boolean>(
            3);
        deltas.put(key, deltaListMapValues);
      }
      deltaListMapValues.put(value, Boolean.TRUE);
    }

    //Handle change on full map
    List<Object> fullListValues = (List<Object>) fullState.get(key);
    if (fullListValues == null) {
      fullListValues = new DeltaStateHelper.InternalList<Object>(3);
      fullState.put(key, fullListValues);
    }
    fullListValues.add(value);
  }

  public Object eval(Serializable key) {
    Object returnValue = fullState.get(key);
    if (returnValue != null) {
      return returnValue;
    }
    ValueExpression expression = target.getValueExpression(key
        .toString());
    if (expression != null) {
      return expression.getValue(FacesContext.getCurrentInstance()
          .getELContext());
    }
    return null;
  }

  public Object eval(Serializable key, Object defaultValue) {
    Object returnValue = fullState.get(key);
    if (returnValue != null) {
      return returnValue;
    }
    ValueExpression expression = target.getValueExpression(key
        .toString());
    if (expression != null) {
      return expression.getValue(FacesContext.getCurrentInstance()
          .getELContext());
    }
    return defaultValue;
  }

  public Object get(Serializable key) {
    return fullState.get(key);
  }

  public Object put(Serializable key, Object value) {
    Object returnValue = null;
    if (createDeltas()) {
      if (deltas.containsKey(key)) {
        returnValue = deltas.put(key, value);
        fullState.put(key, value);
      } else if (value == null && !fullState.containsKey(key)) {
        returnValue = null;
      } else {
        deltas.put(key, value);
        returnValue = fullState.put(key, value);
      }
    } else {
            /*
            if (value instanceof StateHolder)
            {
                _stateHolderKeys.add(key);
            }
            */
      returnValue = fullState.put(key, value);
    }
    return returnValue;
  }

  public Object put(Serializable key, String mapKey, Object value) {
    boolean returnSet = false;
    Object returnValue = null;
    if (createDeltas()) {
      //Track delta case
      Map<String, Object> mapValues = (Map<String, Object>) deltas
          .get(key);
      if (mapValues == null) {
        mapValues = new DeltaStateHelper.InternalMap<String, Object>();
        deltas.put(key, mapValues);
      }
      if (mapValues.containsKey(mapKey)) {
        returnValue = mapValues.put(mapKey, value);
        returnSet = true;
      } else {
        mapValues.put(mapKey, value);
      }
    }

    //Handle change on full map
    Map<String, Object> mapValues = (Map<String, Object>) fullState
        .get(key);
    if (mapValues == null) {
      mapValues = new DeltaStateHelper.InternalMap<String, Object>();
      fullState.put(key, mapValues);
    }
    if (returnSet) {
      mapValues.put(mapKey, value);
    } else {
      returnValue = mapValues.put(mapKey, value);
    }
    return returnValue;
  }

  public Object remove(Serializable key) {
    Object returnValue = null;
    if (createDeltas()) {
      if (deltas.containsKey(key)) {
        // Keep track of the removed values using key/null pair on the delta map
        returnValue = deltas.put(key, null);
        fullState.remove(key);
      } else {
        // Keep track of the removed values using key/null pair on the delta map
        deltas.put(key, null);
        returnValue = fullState.remove(key);
      }
    } else {
      returnValue = fullState.remove(key);
    }
    return returnValue;
  }

  public Object remove(Serializable key, Object valueOrKey) {
    // Comment by lu4242 : The spec javadoc says if it is a Collection
    // or Map deal with it. But the intention of this method is work
    // with add(?,?) and put(?,?,?), this ones return instances of
    // InternalMap and InternalList to prevent mixing, so to be
    // consistent we'll cast to those classes here.

    Object collectionOrMap = fullState.get(key);
    Object returnValue = null;
    if (collectionOrMap instanceof DeltaStateHelper.InternalMap) {
      if (createDeltas()) {
        returnValue = removeValueOrKeyFromMap(deltas, key,
            valueOrKey, true);
        removeValueOrKeyFromMap(fullState, key, valueOrKey, false);
      } else {
        returnValue = removeValueOrKeyFromMap(fullState, key,
            valueOrKey, false);
      }
    } else if (collectionOrMap instanceof DeltaStateHelper.InternalList) {
      if (createDeltas()) {
        returnValue = removeValueOrKeyFromCollectionDelta(deltas,
            key, valueOrKey);
        removeValueOrKeyFromCollection(fullState, key, valueOrKey);
      } else {
        returnValue = removeValueOrKeyFromCollection(fullState, key,
            valueOrKey);
      }
    }
    return returnValue;
  }

  private static Object removeValueOrKeyFromCollectionDelta(
      Map<Serializable, Object> stateMap, Serializable key,
      Object valueOrKey) {
    Object returnValue = null;
    Map<Object, Boolean> c = (Map<Object, Boolean>) stateMap.get(key);
    if (c != null) {
      if (c.containsKey(valueOrKey)) {
        returnValue = valueOrKey;
      }
      c.put(valueOrKey, Boolean.FALSE);
    }
    return returnValue;
  }

  private static Object removeValueOrKeyFromCollection(
      Map<Serializable, Object> stateMap, Serializable key,
      Object valueOrKey) {
    Object returnValue = null;
    Collection c = (Collection) stateMap.get(key);
    if (c != null) {
      if (c.remove(valueOrKey)) {
        returnValue = valueOrKey;
      }
      if (c.isEmpty()) {
        stateMap.remove(key);
      }
    }
    return returnValue;
  }

  private static Object removeValueOrKeyFromMap(
      Map<Serializable, Object> stateMap, Serializable key,
      Object valueOrKey, boolean delta) {
    if (valueOrKey == null) {
      return null;
    }

    Object returnValue = null;
    Map<String, Object> map = (Map<String, Object>) stateMap.get(key);
    if (map != null) {
      if (delta) {
        // Keep track of the removed values using key/null pair on the delta map
        returnValue = map.put((String) valueOrKey, null);
      } else {
        returnValue = map.remove(valueOrKey);
      }

      if (map.isEmpty()) {
        //stateMap.remove(key);
        stateMap.put(key, null);
      }
    }
    return returnValue;
  }

  public boolean isTransient() {
    return transientBoolean;
  }

  /**
   * Serializing cod
   * the serialized data structure consists of key value pairs unless the value itself is an internal array
   * or a map in case of an internal array or map the value itself is another array with its initial value
   * myfaces.InternalArray, myfaces.internalMap
   * <p>
   * the internal Array is then mapped to another array
   * <p>
   * the internal Map again is then mapped to a map with key value pairs
   */
  public Object saveState(FacesContext context) {
    Map serializableMap = (isInitialStateMarked()) ? deltas : fullState;

    if (serializableMap == null || serializableMap.size() == 0) {
      return null;
    }

        /*
        int stateHolderKeyCount = 0;
        if (isInitalStateMarked())
        {
            for (Iterator<Serializable> it = _stateHolderKeys.iterator(); it.hasNext();)
            {
                Serializable key = it.next();
                if (!deltas.containsKey(key))
                {
                    stateHolderKeyCount++;
                }
            }
        }*/

    Map.Entry<Serializable, Object> entry;
    //entry == key, value, key, value
    Object[] retArr = new Object[serializableMap.entrySet().size() * 2];
    //Object[] retArr = new Object[serializableMap.entrySet().size() * 2 + stateHolderKeyCount];

    Iterator<Map.Entry<Serializable, Object>> it = serializableMap.entrySet().iterator();
    int cnt = 0;
    while (it.hasNext()) {
      entry = it.next();
      retArr[cnt] = entry.getKey();

      Object value = entry.getValue();

      // The condition in which the call to saveAttachedState
      // is to handle List, StateHolder or non Serializable instances.
      // we check it here, to prevent unnecessary calls.
      if (value instanceof StateHolder || value instanceof List || !(value instanceof Serializable)) {
        Object savedValue = saveAttachedState(context, value);
        retArr[cnt + 1] = savedValue;
      } else {
        retArr[cnt + 1] = value;
      }
      cnt += 2;
    }

        /*
        if (isInitalStateMarked())
        {
            for (Iterator<Serializable> it2 = _stateHolderKeys.iterator(); it.hasNext();)
            {
                Serializable key = it2.next();
                if (!deltas.containsKey(key))
                {
                    retArr[cnt] = key;
                    Object value = fullState.get(key);
                    if (value instanceof PartialStateHolder)
                    {
                        //Could contain delta, save it as _AttachedDeltaState
                        PartialStateHolder holder = (PartialStateHolder) value;
                        if (holder.isTransient())
                        {
                            retArr[cnt + 1] = null;
                        }
                        else
                        {
                            retArr[cnt + 1] = new _AttachedDeltaWrapper(value.getClass(), holder.saveState(context));
                        }
                    }
                    else
                    {
                        //Save everything
                        retArr[cnt + 1] = saveAttachedState(context, fullState.get(key));
                    }
                    cnt += 2;
                }
            }
        }
        */
    return retArr;
  }

  public void restoreState(FacesContext context, Object state) {
    if (state == null) {
      return;
    }

    Object[] serializedState = (Object[]) state;

    if (!isInitialStateMarked() && !fullState.isEmpty()) {
      fullState.clear();
      if (deltas != null) {
        deltas.clear();
      }
    }

    for (int cnt = 0; cnt < serializedState.length; cnt += 2) {
      Serializable key = (Serializable) serializedState[cnt];
      Object savedValue = restoreAttachedState(context,
          serializedState[cnt + 1]);

      if (isInitialStateMarked()) {
        if (savedValue instanceof DeltaStateHelper.InternalDeltaListMap) {
          for (Map.Entry<Object, Boolean> mapEntry : ((Map<Object, Boolean>) savedValue)
              .entrySet()) {
            boolean addOrRemove = mapEntry.getValue();
            if (addOrRemove) {
              //add
              this.add(key, mapEntry.getKey());
            } else {
              //remove
              this.remove(key, mapEntry.getKey());
            }
          }
        } else if (savedValue instanceof DeltaStateHelper.InternalMap) {
          for (Map.Entry<String, Object> mapEntry : ((Map<String, Object>) savedValue)
              .entrySet()) {
            this.put(key, mapEntry.getKey(), mapEntry.getValue());
          }
                /*
                else if (savedValue instanceof _AttachedDeltaWrapper)
                {
                    AttachedStateWrapper wrapper = (AttachedStateWrapper) savedValue;
                    //Restore delta state
                    ((PartialStateHolder)fullState.get(key)).restoreState(context, wrapper.getWrappedStateObject());
                    //Add this key as StateHolder key
                    _stateHolderKeys.add(key);
                }
                */
        } else {
          put(key, savedValue);
        }
      } else {
        put(key, savedValue);
      }
    }
  }

  public void setTransient(boolean transientValue) {
    transientBoolean = transientValue;
  }

  //We use our own data structures just to make sure
  //nothing gets mixed up internally
  static class InternalMap<K, V> extends HashMap<K, V> implements StateHolder {
    public InternalMap() {
      super();
    }

    public InternalMap(int initialCapacity, float loadFactor) {
      super(initialCapacity, loadFactor);
    }

    public InternalMap(Map<? extends K, ? extends V> m) {
      super(m);
    }

    public InternalMap(int initialSize) {
      super(initialSize);
    }

    public boolean isTransient() {
      return false;
    }

    public void setTransient(boolean newTransientValue) {
      // No op
    }

    public void restoreState(FacesContext context, Object state) {
      Object[] listAsMap = (Object[]) state;
      for (int cnt = 0; cnt < listAsMap.length; cnt += 2) {
        this.put((K) listAsMap[cnt], (V) UIComponentBase.restoreAttachedState(context, listAsMap[cnt + 1]));
      }
    }

    public Object saveState(FacesContext context) {
      int cnt = 0;
      Object[] mapArr = new Object[this.size() * 2];
      for (Map.Entry<K, V> entry : this.entrySet()) {
        mapArr[cnt] = entry.getKey();
        Object value = entry.getValue();

        if (value instanceof StateHolder || value instanceof List || !(value instanceof Serializable)) {
          mapArr[cnt + 1] = saveAttachedState(context, value);
        } else {
          mapArr[cnt + 1] = value;
        }
        cnt += 2;
      }
      return mapArr;
    }
  }

  /**
   * Map used to keep track of list changes
   */
  static class InternalDeltaListMap<K, V> extends DeltaStateHelper.InternalMap<K, V> {

    public InternalDeltaListMap() {
      super();
    }

    public InternalDeltaListMap(int initialCapacity, float loadFactor) {
      super(initialCapacity, loadFactor);
    }

    public InternalDeltaListMap(int initialSize) {
      super(initialSize);
    }

    public InternalDeltaListMap(Map<? extends K, ? extends V> m) {
      super(m);
    }
  }

  static class InternalList<T> extends ArrayList<T> implements StateHolder {
    public InternalList() {
      super();
    }

    public InternalList(Collection<? extends T> c) {
      super(c);
    }

    public InternalList(int initialSize) {
      super(initialSize);
    }

    public boolean isTransient() {
      return false;
    }

    public void setTransient(boolean newTransientValue) {
    }

    public void restoreState(FacesContext context, Object state) {
      Object[] listAsArr = (Object[]) state;
      //since all other options would mean dual iteration
      //we have to do it the hard way
      for (Object elem : listAsArr) {
        add((T) restoreAttachedState(context, elem));
      }
    }

    public Object saveState(FacesContext context) {
      Object[] values = new Object[size()];
      for (int i = 0; i < size(); i++) {
        Object value = get(i);

        if (value instanceof StateHolder || value instanceof List || !(value instanceof Serializable)) {
          values[i] = saveAttachedState(context, value);
        } else {
          values[i] = value;
        }
      }
      return values;
    }
  }

  private static Object saveAttachedState(FacesContext context, Object attachedObject) {
    if (context == null) {
      throw new NullPointerException("context");
    }

    if (attachedObject == null) {
      return null;
    }
    // StateHolder interface should take precedence over
    // List children
    if (attachedObject instanceof StateHolder) {
      StateHolder holder = (StateHolder) attachedObject;
      if (holder.isTransient()) {
        return null;
      }

      return new AttachedStateWrapper(attachedObject.getClass(), holder.saveState(context));
    } else if (attachedObject instanceof List) {
      List<Object> lst = new ArrayList<Object>(((List<?>) attachedObject).size());
      for (Object item : (List<?>) attachedObject) {
        if (item != null) {
          lst.add(saveAttachedState(context, item));
        }
      }

      return new AttachedListStateWrapper(lst);
    } else if (attachedObject instanceof Serializable) {
      return attachedObject;
    } else {
      return new AttachedStateWrapper(attachedObject.getClass(), null);
    }
  }

  private static Object restoreAttachedState(FacesContext context, Object stateObj) throws IllegalStateException {
    if (context == null) {
      throw new NullPointerException("context");
    }
    if (stateObj == null) {
      return null;
    }
    if (stateObj instanceof AttachedListStateWrapper) {
      List<Object> lst = ((AttachedListStateWrapper) stateObj).getWrappedStateList();
      List<Object> restoredList = new ArrayList<Object>(lst.size());
      for (Object item : lst) {
        restoredList.add(restoreAttachedState(context, item));
      }
      return restoredList;
    } else if (stateObj instanceof AttachedStateWrapper) {
      Class<?> clazz = ((AttachedStateWrapper) stateObj).getClazz();
      Object restoredObject;
      try {
        restoredObject = clazz.newInstance();
      } catch (InstantiationException e) {
        throw new RuntimeException("Could not restore StateHolder of type " + clazz.getName()
            + " (missing no-args constructor?)", e);
      } catch (IllegalAccessException e) {
        throw new RuntimeException(e);
      }
      if (restoredObject instanceof StateHolder) {
        AttachedStateWrapper wrapper = (AttachedStateWrapper) stateObj;
        Object wrappedState = wrapper.getWrappedStateObject();

        StateHolder holder = (StateHolder) restoredObject;
        holder.restoreState(context, wrappedState);
      }
      return restoredObject;
    } else {
      return stateObj;
    }
  }
}
