ELFlash.java

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License.  You can
 * obtain a copy of the License at
 * https://glassfish.java.net/public/CDDL+GPL_1_1.html
 * or packager/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at packager/legal/LICENSE.txt.
 *
 * GPL Classpath Exception:
 * Oracle designates this particular file as subject to the "Classpath"
 * exception as provided by Oracle in the GPL Version 2 section of the License
 * file that accompanied this code.
 *
 * Modifications:
 * If applicable, add the following below the License Header, with the fields
 * enclosed by brackets [] replaced by your own identifying information:
 * "Portions Copyright [year] [name of copyright owner]"
 *
 * Contributor(s):
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

package com.sun.faces.context.flash;

import static com.sun.faces.config.WebConfiguration.BooleanWebContextInitParameter.EnableDistributable;
import static com.sun.faces.config.WebConfiguration.BooleanWebContextInitParameter.ForceAlwaysWriteFlashCookie;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.security.InvalidKeyException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.faces.application.FacesMessage;
import javax.faces.component.UIViewRoot;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.context.Flash;
import javax.faces.event.PhaseId;
import javax.faces.event.PostKeepFlashValueEvent;
import javax.faces.event.PostPutFlashValueEvent;
import javax.faces.event.PreClearFlashEvent;
import javax.faces.event.PreRemoveFlashValueEvent;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;

import com.sun.faces.config.WebConfiguration;
import com.sun.faces.config.WebConfiguration.WebContextInitParameter;
import com.sun.faces.facelets.tag.ui.UIDebug;
import com.sun.faces.util.ByteArrayGuardAESCTR;
import com.sun.faces.util.FacesLogger;

/**
 * <p>How this implementation works</p>

 * <p>This class is an application singleton.  It has one ivar, 
 * innerMap.  Entries are added to and removed from this map as needed
 * according to how the flash scope is defined in the spec.  This
 * implementation never touches the session, nor does it cause the
 * session to be created.</p>

 * <p>Most of the hairy logic is encapsulated with in the inner class
 * PreviousNextFlashInfoManager.  An instance of this class is
 * obtained by calling one of the variants of getCurrentFlashManager().
 * When the instance is no longer needed for this request, call
 * releaseCurrentFlashManager().</p>

 * <p>Two very important methods are getPhaseMapForWriting() and
 * getPhaseMapForReading().  These methods are the basis for the
 * Map implementation methods.  Methods that need to write to the map
 * use getPhaseMapForWriting(), those that need to read use
 * getPhaseMapForReading().  These methods allow for the laziness that
 * allows us to only incur a cost when the flash is actually written
 * to.</p>

 * <p>The operation of this class is intimately tied to the request
 * processing lifecycle.  Let's break down every run thru the request
 * processing lifecycle into two parts called "previous" and "next".  We
 * use the names "previous" and "next" to indicate the persistence and
 * timing of the data that is stored in the flash.  Consider two runs
 * through the requset processing lifecle: N and N+1.  On request N,
 * there is no "previous" request.  On Request N, any writes to the
 * flash that happen during RENDER RESPONSE go to the "next" flash map.
 * This means they are available for the ENTIRE run though the request
 * processing lifecycle on request N+1.  Any entries put into the "next"
 * flash map on request N will be expired at the end of request N+1.
 * Now, when we get into request N+1 what was considered "next" on
 * request N, is now called "previous" from the perspective of request
 * N+1.  Any reads from the flash during request N+1 come from the
 * "previous" map.  Any writes to the flash before RENDER RESPONSE go to
 * the "previous" map.  Any writes to the flash during RENDER RESPNOSE
 * go to the "next" map.</p>
 */

public class ELFlash extends Flash {

    // <editor-fold defaultstate="collapsed" desc="ivars">

    /**
     * <p>Keys in this map are the string version of sequence numbers
     * obtained via calls to {@link #getNewSequenceNumber}.  Values are
     * the actual Map instances that back the actual Map methods on this
     * class.  All writes to and reads from this map are done by the
     * {@link PreviousNextFlashInfoManager} inner class.</p>
     * 
     */
    private Map<String,Map<String, Object>> flashInnerMap = null;

    private final AtomicLong sequenceNumber = new AtomicLong(0);

    private int numberOfConcurentFlashUsers = Integer.
     parseInt(WebContextInitParameter.NumberOfConcurrentFlashUsers.getDefaultValue());

    private long numberOfFlashesBetweenFlashReapings = Long.
     parseLong(WebContextInitParameter.NumberOfFlashesBetweenFlashReapings.getDefaultValue());
    
    private final boolean distributable;
    
    private ByteArrayGuardAESCTR guard;
    
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="class vars">
    
    private static final String ELEMENT_TYPE_MISMATCH = "element-type-mismatch";
    
    private static final Logger LOGGER = FacesLogger.FLASH.getLogger();

    /**
     * <p>These constants are referenced from other source files in this
     * package.  This one is a disambiguator prefix.</p>
     */
    static final String PREFIX = "csfcf";

    /**
     * <p>This constant is used as the key in the application map that
     * stores the singleton ELFlash instance.</p>
     */
    static final String FLASH_ATTRIBUTE_NAME = PREFIX + "f";
    
    /**
     * <p>This constant is used as the name of the cookie sent to the
     * client.  The cookie is used to allow the flash scope to
     * be used to support POST REDIRECT GET navigation.</p>
     */
    static final String FLASH_COOKIE_NAME = PREFIX + "c";


    /**
     * <p>This constant is used as the key the request map used, in the
     * FlashELResolver, to convey the name of the property being
     * accessed via 'now'.</p>
     */
    static final String FLASH_NOW_REQUEST_KEY = FLASH_ATTRIBUTE_NAME + "n";

    private enum CONSTANTS {

	/**
	 * The key in the FacesContext attributes map (hereafter
	 * referred to as contextMap) for the request scoped {@link
	 * PreviousNextFlashInfoManager}.
	 */

        RequestFlashManager,

	/**
	 * At the beginning of every phase, we save the value of the
	 * facesContext.getResponseComplete() into the contextMap under
	 * this key.  We check this value after the phase to see if this
	 * is the phase where the user called responseComplete().  This
	 * is important to cover cases when the user does some funny
	 * lifecycle stuff.
	 */

        SavedResponseCompleteFlagValue,

        /**
	 * This is used as the key in the flash itself to store the messages
	 * if they are being tracked.
	 */

        FacesMessageAttributeName,

        /**
	 * This is used as the key in the flash itself to track whether or not
	 * messages are being saved across request/response boundaries.
	 */

        KeepAllMessagesAttributeName,

        /**
         * This key is used in the contextMap to indicate that the next
         * get should be treated as a keep.
         *
         */
        KeepFlagAttributeName,

        /**
         * This key is used in the contextMap to prevent setting the cookie
         * twice.
         */
        DidWriteCookieAttributeName,
        
        /**
         * Force setMaxAge(0)
         */
        ForceSetMaxAgeZero,

    }

    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Constructors and instance accessors">

    /** Creates a new instance of ELFlash */
    private ELFlash(ExternalContext extContext) {
        flashInnerMap = new ConcurrentHashMap<>();
        WebConfiguration config = WebConfiguration.getInstance(extContext);
        String value;
        try {
            value = config.getOptionValue(WebContextInitParameter.NumberOfConcurrentFlashUsers);
            numberOfConcurentFlashUsers = Integer.parseInt(value);
        } catch (NumberFormatException nfe) {
	    if (LOGGER.isLoggable(Level.WARNING)) {
		LOGGER.log(Level.WARNING, "Unable to set number of concurrent flash users.  Defaulting to {0}", numberOfConcurentFlashUsers);
	    }

        }

        try {
            value = config.getOptionValue(WebContextInitParameter.NumberOfFlashesBetweenFlashReapings);
            numberOfFlashesBetweenFlashReapings = Long.parseLong(value);
        } catch (NumberFormatException nfe) {
	    if (LOGGER.isLoggable(Level.WARNING)) {
		LOGGER.log(Level.WARNING, "Unable to set number flashes between flash repaings.  Defaulting to {0}", numberOfFlashesBetweenFlashReapings);
	    }

        }
        
        distributable = config.isOptionEnabled(EnableDistributable);
        
        guard = new ByteArrayGuardAESCTR();

    }

    /**
     * <p>Returns the flash <code>Map</code> for this application.  This is
     * a convenience method that calls
     * <code>FacesContext.getCurrentInstance()</code> and then calls the
     * overloaded <code>getFlash()</code> that takes a
     * <code>FacesContext</code> with it.</p>
     * 
     * @return The flash <code>Map</code> for this session.
     */
    
    public static Map<String,Object> getFlash() {
        FacesContext context = FacesContext.getCurrentInstance();
        return getFlash(context.getExternalContext(), true);
    }

    /**
     *
     * @param extContext the <code>ExternalContext</code> for this request.
     *
     * @param create <code>true</code> to create a new instance for this request if 
     * necessary; <code>false</code> to return <code>null</code> if there's no 
     * instance in the current <code>session</code>.
     * 
     * @return The flash <code>Map</code> for this session.
     */
    
    static ELFlash getFlash(ExternalContext extContext, boolean create) {
        Map<String, Object> appMap = extContext.getApplicationMap();
        ELFlash flash = (ELFlash) 
            appMap.get(FLASH_ATTRIBUTE_NAME);
        if (null == flash && create) {
            synchronized (extContext.getContext()) {
                if (null == (flash = (ELFlash)
                        appMap.get(FLASH_ATTRIBUTE_NAME))) {
                    flash = new ELFlash(extContext);
                    appMap.put(FLASH_ATTRIBUTE_NAME, flash);
                }
            }            
        }
        
        /*
         * If we are in a clustered environment and a session is active, store
         * a helper to ensure our innerMap gets successfully replicated.
         */
        if (appMap.get(EnableDistributable.getQualifiedName()) != null) {
            synchronized (extContext.getContext()) {
                if (extContext.getSession(false) != null) {
                    SessionHelper sessionHelper = SessionHelper.getInstance(extContext);
                    if (sessionHelper == null) {
                        sessionHelper = new SessionHelper();
                    }
                    sessionHelper.update(extContext, flash);
                }
            }
        }
        
        return flash;
    }
    
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Abstract class overrides">

    
    @Override
    public boolean isKeepMessages() {
        boolean result = false;
        Map<String, Object> phaseMap;

        if (null != (phaseMap = loggingGetPhaseMapForReading(false))) {
            Object value = phaseMap.get(CONSTANTS.KeepAllMessagesAttributeName.toString());
            result = (null != value) ? (Boolean) value : false;
        }
        
        return result;
    }
    
    
    @Override
    public void setKeepMessages(boolean newValue) {

        loggingGetPhaseMapForWriting(false).put(CONSTANTS.KeepAllMessagesAttributeName.toString(),
                Boolean.valueOf(newValue));

    }
    
    
    @Override
    public boolean isRedirect() {
        boolean result = false;

        FacesContext context = FacesContext.getCurrentInstance();
        Map<Object, Object> contextMap = context.getAttributes();
        PreviousNextFlashInfoManager flashManager;
        if (null != (flashManager = getCurrentFlashManager(contextMap, false))) {
            result = flashManager.getPreviousRequestFlashInfo().isIsRedirect();
        }

        return result;
    }
    

    // PENDING(edburns): I'm going to make an entry to the errata.  This
    // method can't be implemented because the decision of whether or
    // not to redirect is made by the navigationHandler.
    @Override
    public void setRedirect(boolean newValue) {
    }

    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Map overrides">

    
    @SuppressWarnings(ELEMENT_TYPE_MISMATCH)
    @Override
    public Object get(Object key) {
        Object result = null;

        FacesContext context = FacesContext.getCurrentInstance();
        if (null != key) {
            if (key.equals("keepMessages")) {
                result = this.isKeepMessages();
            } else if (key.equals("redirect")) {
                result = this.isRedirect();
            } else {
                if (isKeepFlagSet(context)) {
                    result = getPhaseMapForReading().get(key);
                    keep(key.toString());
                    clearKeepFlag(context);
                    return result;
                }

            }

        }
        
        if (null == result) {
            result = getPhaseMapForReading().get(key);
        }
        if (distributable && context.getExternalContext().getSession(false) != null) {
            SessionHelper sessionHelper = 
                    SessionHelper.getInstance(context.getExternalContext());
            if (sessionHelper != null) {
              sessionHelper.update(context.getExternalContext(), this);
            }
        }

        if (LOGGER.isLoggable(Level.FINEST)) {
            LOGGER.log(Level.FINEST, "get({0}) = {1}", new Object [] { key, result});
        }

        return result;
    }


    @Override
    public Object put(String key, Object value) {
        Boolean b = null;
        Object result = null;
        boolean wasSpecialPut = false;

        if (null != key) {
            if (key.equals("keepMessages")) {
                this.setKeepMessages(b = Boolean.parseBoolean((String) value));
                wasSpecialPut = true;
            }
            if (key.equals("redirect")) {
                this.setRedirect(b = Boolean.parseBoolean((String) value));
                wasSpecialPut = true;
            }
        }
        FacesContext context = FacesContext.getCurrentInstance();
        if (!wasSpecialPut) {
            result = (null == b) ? getPhaseMapForWriting().put(key, value) : b;
            if (LOGGER.isLoggable(Level.FINEST)) {
                LOGGER.log(Level.FINEST, "put({0},{1})", new Object [] { key, value});
            }
            context.getApplication().publishEvent(context, PostPutFlashValueEvent.class, key);
        }
        if (distributable && context.getExternalContext().getSession(false) != null) {
            SessionHelper sessionHelper = 
                    SessionHelper.getInstance(context.getExternalContext());
            if (sessionHelper != null) {
                sessionHelper.update(context.getExternalContext(), this);
            }
        }
        
        return result;
    }

    @SuppressWarnings(ELEMENT_TYPE_MISMATCH)
    @Override
    public Object remove(Object key) {
        Object result = null;

        FacesContext context = FacesContext.getCurrentInstance();
        context.getApplication().publishEvent(context, PreRemoveFlashValueEvent.class, key);
        result = getPhaseMapForWriting().remove(key);

        return result;
    }

    
    @SuppressWarnings(ELEMENT_TYPE_MISMATCH)
    @Override
    public boolean containsKey(Object key) {
        boolean result = false;

        result = getPhaseMapForReading().containsKey(key);

        return result;
    }

    
    @Override
    public boolean containsValue(Object value) {
        boolean result = false;

        result = getPhaseMapForReading().containsValue(value);

        return result;
    }

    
    @Override
    public void putAll(Map<? extends String, ?> t) {

        getPhaseMapForWriting().putAll(t);

    }

    
    @Override
    public Collection<Object> values() {
        Collection<Object> result = null;

        result = getPhaseMapForReading().values();

        return result;
    }

    
    @Override
    public int size() {
        int result = 0;

        result = getPhaseMapForReading().size();

        return result;
    }

    
    @Override
    public void clear() {

        getPhaseMapForWriting().clear();

    }

    
    @SuppressWarnings({"CloneDoesntCallSuperClone"})
    @Override
    protected Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }

    
    @Override
    public Set<Map.Entry<String, Object>> entrySet() {
        Set<Map.Entry<String, Object>> 
                readingMapEntrySet = getPhaseMapForReading().entrySet(),
                writingMapEntrySet = getPhaseMapForWriting().entrySet(),
                result = null;

        result = new HashSet<>();
        result.addAll(readingMapEntrySet);
        result.addAll(writingMapEntrySet);

        return result;
    }

    
    @Override
    public boolean isEmpty() {
        boolean 
                readingMapIsEmpty = getPhaseMapForReading().isEmpty(),
                writingMapIsEmpty = getPhaseMapForWriting().isEmpty(),
                result = false;

        result = readingMapIsEmpty && writingMapIsEmpty;

        return result;
    }

    
    @Override
    public Set<String> keySet() {
        Set<String>
                readingMapKeySet = getPhaseMapForReading().keySet(),
                writingMapKeySet = getPhaseMapForWriting().keySet(),
                result = null;

        result = new HashSet<>();
        result.addAll(readingMapKeySet);
        result.addAll(writingMapKeySet);

        return result;
    }

    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Flash overrides">

    
    @Override
    public void keep(String key) {
        FacesContext context = FacesContext.getCurrentInstance();
        Map<String, Object> requestMap = context.getExternalContext().getRequestMap();
        Map<Object, Object> contextMap = context.getAttributes();
        PreviousNextFlashInfoManager flashManager;
        if (null != (flashManager = getCurrentFlashManager(contextMap, true))) {
            Object toKeep;

            if (null == (toKeep = requestMap.remove(key))) {
                FlashInfo flashInfo = null;
                if (null != (flashInfo = flashManager.getPreviousRequestFlashInfo())) {
                    toKeep = flashInfo.getFlashMap().get(key);
                }
            }

            if (null != toKeep) {
                getPhaseMapForWriting().put(key, toKeep);
                context.getApplication().publishEvent(context, PostKeepFlashValueEvent.class, key);

            }
        }


    }

    
    @Override
    public void putNow(String key, Object value) {
        FacesContext context = FacesContext.getCurrentInstance();
        Map<Object, Object> contextMap = context.getAttributes();
        PreviousNextFlashInfoManager flashManager;
        if (null != (flashManager = getCurrentFlashManager(contextMap, true))) {
            FlashInfo flashInfo = null;
            if (null != (flashInfo = flashManager.getPreviousRequestFlashInfo())) {
                flashInfo.getFlashMap().put(key, value);
            }
        }
    }
    
    @Override
    public void doPrePhaseActions(FacesContext context) {
        PhaseId currentPhase = context.getCurrentPhaseId();
        Map<Object, Object> contextMap = context.getAttributes();
        contextMap.put(CONSTANTS.SavedResponseCompleteFlagValue,
                context.getResponseComplete());

        Cookie cookie = null;
        if (currentPhase.equals(PhaseId.RESTORE_VIEW)) {

            if (null != (cookie = getCookie(context.getExternalContext()))) {
                getCurrentFlashManager(context, contextMap, cookie);
            }

            if (this.isKeepMessages()) {
                this.restoreAllMessages(context);
            }
        } else if (currentPhase.equals(PhaseId.RENDER_RESPONSE) && 
            contextMap.containsKey(ForceAlwaysWriteFlashCookie) && 
                (Boolean) contextMap.get(ForceAlwaysWriteFlashCookie)) {
            PreviousNextFlashInfoManager flashManager = getCurrentFlashManager(contextMap, true);
            cookie = flashManager.encode();
            if (null != cookie) {
                setCookie(context, flashManager, cookie, true);
            } else {
                if (LOGGER.isLoggable(Level.WARNING)) {
                    LOGGER.log(Level.WARNING,
                            "jsf.externalcontext.flash.force.write.cookie.failed");
                }
            }
        }

    }

    @Override
    public void doPostPhaseActions(FacesContext context) {
        if (context.getAttributes().containsKey(ACT_AS_DO_LAST_PHASE_ACTIONS)) {
            Boolean outgoingResponseIsRedirect = 
                    (Boolean) context.getAttributes().get(ACT_AS_DO_LAST_PHASE_ACTIONS);
            doLastPhaseActions(context, outgoingResponseIsRedirect);
            return;
        }
        
        PhaseId currentPhase = context.getCurrentPhaseId();
        Map<Object, Object> contextMap = context.getAttributes();
        boolean
                responseCompleteJustSetTrue = responseCompleteWasJustSetTrue(context, contextMap),
                lastPhaseForThisRequest = responseCompleteJustSetTrue ||
                                          currentPhase == PhaseId.RENDER_RESPONSE;
        if (lastPhaseForThisRequest) {
            doLastPhaseActions(context, false);
        }
    }
    
    public static final String ACT_AS_DO_LAST_PHASE_ACTIONS = 
            ELFlash.class.getPackage().getName() + ".ACT_AS_DO_LAST_PHASE_ACTIONS";

    /**
     * <p>This is the most magic of methods.  There are several scenarios
     * in which this method can be called, but the first time it is
     * called for a request it takes action, while on subsequent times
     * it returns without taking action.  This is due to the call to
     * {@link #releaseCurrentFlashManager}.  After this call, any calls
     * to {@link #getCurrentFlashManager} will return null.</p>

     * <p>Scenario 1: normal request ending.  This will be called after
     * the RENDER_RESPONSE phase executes.  outgoingResponseIsRedirect will be false.</p>

     * <p>Scenario 2: navigationHandler asks extContext for redirect.
     * In this case, extContext calls this method directly,
     * outgoingResponseIsRedirect will be true.</p>

     * <p>Scenario 3: extContext.flushBuffer(): As far as I can tell,
     * this is only called in the JSP case, but it's good to call it
     * from there anyway, because we need to write our cookie before the
     * response is committed.  outgoingResponseIsRedirect is false.</p>

     * <p>Scenario 4: after rendering the response in JSP, but before
     * the buffer is flushed.  In the JSP case, I've found this necessary
     * because the call to extContext.flushBuffer() is too late, the
     * response has already been committed by that
     * point. outgoingResponseIsRedirect is false.</p>
     */

    public void doLastPhaseActions(FacesContext context, boolean outgoingResponseIsRedirect) {
        Map<Object, Object> contextMap = context.getAttributes();
        PreviousNextFlashInfoManager flashManager = getCurrentFlashManager(contextMap, false);
        if (null == flashManager) {
            return;
        }
        if (this.isKeepMessages()) {
            this.saveAllMessages(context);
        }
        releaseCurrentFlashManager(contextMap);

	// What we do in this if-else statement has consequences for
	// PreviousNextFlashInfoManager.decode().
        
        if (outgoingResponseIsRedirect) {
            FlashInfo previousRequestFlashInfo = flashManager.getPreviousRequestFlashInfo();
	    // Next two methods are VITALLY IMPORTANT!
            previousRequestFlashInfo.setIsRedirect(true);
            flashManager.expireNext_MovePreviousToNext();
        } else {
            FlashInfo flashInfo = flashManager.getPreviousRequestFlashInfo();
            if (null != flashInfo && flashInfo.getLifetimeMarker() ==
                LifetimeMarker.SecondTimeThru) {
                flashManager.expirePrevious();
            }
        }
        if (LOGGER.isLoggable(Level.FINEST)) {
            LOGGER.log(Level.FINEST, "---------------------------------------");
        }


        setCookie(context, flashManager, flashManager.encode(), false);

    }

    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Helpers">
    
    void setFlashInnerMap(Map<String,Map<String, Object>> flashInnerMap) {
        this.flashInnerMap = flashInnerMap;
    }
    
    Map<String, Map<String,Object>> getFlashInnerMap() {
        return flashInnerMap;
    }
    
    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("[\n");
        for (Map.Entry<String, Object> entry : this.entrySet()) {
            builder.append("{").append(entry.getKey()).append(", ").append(entry.getValue()).append("}\n");
        }
        builder.append("]\n");
        return builder.toString();
    }

    private void maybeWriteCookie(FacesContext context,
            PreviousNextFlashInfoManager flashManager) {
        FlashInfo flashInfo = flashManager.getPreviousRequestFlashInfo();
        if (null != flashInfo && flashInfo.getLifetimeMarker() ==
            LifetimeMarker.SecondTimeThru) {
            PreviousNextFlashInfoManager copiedFlashManager =
                    flashManager.copyWithoutInnerMap();
            copiedFlashManager.expirePrevious();
            setCookie(context, flashManager,
                    copiedFlashManager.encode(), false);
        }
    }


    static void setKeepFlag(FacesContext context) {
        context.getAttributes().put(CONSTANTS.KeepFlagAttributeName, Boolean.TRUE);
    }

    void clearKeepFlag(FacesContext context) {
        context.getAttributes().remove(CONSTANTS.KeepFlagAttributeName);
    }

    boolean isKeepFlagSet(FacesContext context) {
        return Boolean.TRUE ==
                context.getAttributes().get(CONSTANTS.KeepFlagAttributeName);
    }



    private long getNewSequenceNumber() {
        long result = sequenceNumber.incrementAndGet();

        if (0 == result % numberOfFlashesBetweenFlashReapings) {
            reapFlashes();
        }

        if (result == Long.MAX_VALUE) {
            result = 1;
            sequenceNumber.set(1);
        }

        return result;
    }

    private void reapFlashes() {

        if (flashInnerMap.size() < numberOfConcurentFlashUsers) {
            return;
        }
        
        Set<String> keys = flashInnerMap.keySet();
            long
                    sequenceNumberToTest,
                    currentSequenceNumber = sequenceNumber.get();
        Map<String, Object> curFlash;
        for (String cur : keys) {
            sequenceNumberToTest = Long.parseLong(cur);
            if (numberOfConcurentFlashUsers < currentSequenceNumber - sequenceNumberToTest) {
                if (null != (curFlash = flashInnerMap.get(cur))) {
                    curFlash.clear();
                }
                flashInnerMap.remove(cur);
            }
        }
        if (distributable && FacesContext.getCurrentInstance().getExternalContext().getSession(false) != null) {
            ExternalContext extContext = FacesContext.getCurrentInstance().getExternalContext();
            SessionHelper sessionHelper = SessionHelper.getInstance(extContext);
            if (null != sessionHelper) {
                sessionHelper.remove(extContext);
                sessionHelper = new SessionHelper();
                sessionHelper.update(extContext, this);
            }
        }        
    }

    private boolean responseCompleteWasJustSetTrue(FacesContext context,
            Map<Object, Object> contextMap) {
        boolean result = false;

        // If it was false, but it's now true, return true
        result = (Boolean.FALSE == contextMap.get(CONSTANTS.SavedResponseCompleteFlagValue) &&
                 context.getResponseComplete());

        return result;
    }

    private static String getLogPrefix(FacesContext context) {
        StringBuilder result = new StringBuilder();
        ExternalContext extContext = context.getExternalContext();
        Object request = extContext.getRequest();
        if (request instanceof HttpServletRequest) {
            result.append(((HttpServletRequest)request).getMethod()).append(" ");
        }
        UIViewRoot root = context.getViewRoot();
        if (null != root) {
            String viewId = root.getViewId();
            if (null != viewId) {
                result.append(viewId).append(" ");
            }
        }

        return result.toString();
    }

    private Map<String, Object> loggingGetPhaseMapForWriting(boolean loggingEnabled) {
        FacesContext context = FacesContext.getCurrentInstance();
        Map<String, Object> result = null;
        PhaseId currentPhase = context.getCurrentPhaseId();
        Map<Object, Object> contextMap = context.getAttributes();

        PreviousNextFlashInfoManager flashManager;
        if (null != (flashManager = getCurrentFlashManager(contextMap, true))) {
            FlashInfo flashInfo;
            boolean isDebugLog = loggingEnabled && LOGGER.isLoggable(Level.FINEST);

            if (currentPhase.getOrdinal() < PhaseId.RENDER_RESPONSE.getOrdinal()) {
                flashInfo = flashManager.getPreviousRequestFlashInfo();
                if (isDebugLog) {
                    LOGGER.log(Level.FINEST, "{0}previous[{1}]",
                            new Object[]{getLogPrefix(context),
                                flashInfo.getSequenceNumber()});
                }
            } else {
                flashInfo = flashManager.getNextRequestFlashInfo(this, true);
                if (isDebugLog) {
                    LOGGER.log(Level.FINEST, "{0}next[{1}]",
                            new Object[]{getLogPrefix(context),
                                flashInfo.getSequenceNumber()});
                }
                maybeWriteCookie(context, flashManager);
            }
            result = flashInfo.getFlashMap();
        }

        return result;

    }

    /**
     * <p>If the current phase is earlier than RENDER_RESPONSE, return
     * the map for the "previous" request.  Otherwise, return the map
     * for the "next" request.  Note that we use
     * getCurrentFlashManager(contextMap,true).  This is because if this
     * method is being called, we know we actually need the map, so we
     * have to ensure the underlying data structure is present before
     * trying to access it.</p>
     */

    private Map<String, Object> getPhaseMapForWriting() {
        return loggingGetPhaseMapForWriting(true);
    }


    private Map<String, Object> loggingGetPhaseMapForReading(boolean loggingEnabled) {
        FacesContext context = FacesContext.getCurrentInstance();
        Map<String, Object> result = Collections.emptyMap();
        Map<Object, Object> contextMap = context.getAttributes();

        PreviousNextFlashInfoManager flashManager;
        if (null != (flashManager = getCurrentFlashManager(contextMap, false))) {
            FlashInfo flashInfo;

            if (null != (flashInfo = flashManager.getPreviousRequestFlashInfo())) {
                boolean isDebugLog = loggingEnabled && LOGGER.isLoggable(Level.FINEST);
                if (isDebugLog) {
                    LOGGER.log(Level.FINEST, "{0}previous[{1}]",
                            new Object[]{getLogPrefix(context),
                                flashInfo.getSequenceNumber()});
                }

                result = flashInfo.getFlashMap();
            }
        }

        return result;
    }

    /**
     * <p>Always return the map for the "previous" request.  Note that
     * we use getCurrentFlashManager(contextMap,false).  This is because
     * if this method is being called, and there is pre-existing data in
     * the flash from a previous write, then the
     * PreviousNextFlashInfoManager will already have been created.  If
     * there is not pre-existing data, we don't create the
     * PreviousNextFlashInfoManager, and therefore just return the empty
     * map.</p>
     */

    private Map<String, Object> getPhaseMapForReading() {
        return loggingGetPhaseMapForReading(true);
    }

    void saveAllMessages(FacesContext context) {
        // take no action on the GET that comes after a REDIRECT
        Map<Object, Object> contextMap = context.getAttributes();
        PreviousNextFlashInfoManager flashManager;
        if (null == (flashManager = getCurrentFlashManager(contextMap, true))) {
            return;
        }
        if (flashManager.getPreviousRequestFlashInfo().isIsRedirect()) {
            return;
        }

        Iterator<String> messageClientIds = context.getClientIdsWithMessages();
        List<FacesMessage> facesMessages;
        Map<String, List<FacesMessage>> allFacesMessages = null;
        Iterator<FacesMessage> messageIter;
        String curMessageId;

        // Save all the FacesMessages into a Map, which we store in the flash.

        // Step 1, go through the FacesMessage instances for each clientId
        // in the messageClientIds list.
        while (messageClientIds.hasNext()) {
            curMessageId = messageClientIds.next();
            // Get the messages for this clientId
            messageIter = context.getMessages(curMessageId);
            facesMessages = new ArrayList<>();
            while (messageIter.hasNext()) {
                facesMessages.add(messageIter.next());
            }
            // Add the list to the map
            if (null == allFacesMessages) {
                allFacesMessages = new HashMap<>();
            }
            allFacesMessages.put(curMessageId, facesMessages);
        }
        facesMessages = null;

        // Step 2, go through the FacesMessages that do not have a client
        // id associated with them.
        messageIter = context.getMessages(null);
        // Make sure to overwrite the previous facesMessages list
        facesMessages = new ArrayList<>();
        while (messageIter.hasNext()) {
            facesMessages.add(messageIter.next());
        }
        if (null != facesMessages) {
            // Add the list to the map
            if (null == allFacesMessages) {
                allFacesMessages = new HashMap<>();
            }
            allFacesMessages.put(null, facesMessages);
        }
        getPhaseMapForWriting().put(CONSTANTS.FacesMessageAttributeName.toString(),
                allFacesMessages);

    }

    @SuppressWarnings(ELEMENT_TYPE_MISMATCH)
    void restoreAllMessages(FacesContext context) {
        Map<String, List<FacesMessage>> allFacesMessages;
        Map<String, Object> phaseMap = getPhaseMapForReading();
        List<FacesMessage> facesMessages;


        if (null != (allFacesMessages = (Map<String, List<FacesMessage>>)
                phaseMap.get(CONSTANTS.FacesMessageAttributeName.toString()))) {
            for (Map.Entry<String, List<FacesMessage>> cur : allFacesMessages.entrySet()) {
                if (null != (facesMessages = allFacesMessages.get(cur.getKey()))) {
                    for (FacesMessage curMessage : facesMessages) {
                        context.addMessage(cur.getKey(), curMessage);
                    }
                }
            }
            phaseMap.remove(CONSTANTS.FacesMessageAttributeName.toString());
        }
    }


    /**
     * <p>Return the cookie that came from the browser, if any.</p>
     */
    private Cookie getCookie(ExternalContext extContext) {
        Cookie result = null;

        result = (Cookie) extContext.getRequestCookieMap().get(FLASH_COOKIE_NAME);

        return result;
    }

    /** 
     * <p>Set the cookie iff the response was not yet committed.  If the response
     * was committed, log a warning.</p>
     */

    private void setCookie(FacesContext context, 
            PreviousNextFlashInfoManager flashManager,
            Cookie toSet, boolean forceWrite) {
        Map<Object, Object> contextMap = context.getAttributes();
        ExternalContext extContext = context.getExternalContext();
        if (contextMap.containsKey(CONSTANTS.DidWriteCookieAttributeName)) {
            return;
        }
        FlashInfo
                nextFlash = flashManager.getNextRequestFlashInfo(),
                prevFlash = flashManager.getPreviousRequestFlashInfo();
        if (context.getAttributes().containsKey(CONSTANTS.ForceSetMaxAgeZero)) {
            removeCookie(extContext, toSet);
            return;
        }

        // Don't try to write the cookie unless there is data in the flash.
        if (forceWrite || (null != nextFlash && !nextFlash.getFlashMap().isEmpty()) ||
            (null != prevFlash && !prevFlash.getFlashMap().isEmpty())) {
            if (extContext.isResponseCommitted()) {
                if (LOGGER.isLoggable(Level.WARNING)) {
                    LOGGER.log(Level.WARNING,
                            "jsf.externalcontext.flash.response.already.committed");
                }
            } else {
                Map<String, Object> properties = new HashMap();
                Object val;
                
                if (null != (val = toSet.getComment())) {
                    properties.put("comment", val);
                }
                if (null != (val = toSet.getDomain())) {
                    properties.put("domain", val);
                }
                if (null != (val = toSet.getMaxAge())) {
                    properties.put("maxAge", val);
                }
                if (extContext.isSecure()) {
                    properties.put("secure", Boolean.TRUE);
                } else if (null != (val = toSet.getSecure())) {
                    properties.put("secure", val);
                }
                if (null != (val = toSet.getPath())) {
                    properties.put("path", val);
                }
                properties.put("httpOnly", Boolean.TRUE);
                extContext.addResponseCookie(toSet.getName(), toSet.getValue(), 
                        !properties.isEmpty() ? properties : null);
                properties = null;
            }
            contextMap.put(CONSTANTS.DidWriteCookieAttributeName, Boolean.TRUE);
        } else {
            removeCookie(extContext, toSet);
        }
    }
    
    private void removeCookie(ExternalContext extContext, Cookie toRemove) {
        if (extContext.isResponseCommitted()) {
            return;
        }
        Map<String, Object> properties = new HashMap();
        Object val;
        toRemove.setMaxAge(0);
        
        if (null != (val = toRemove.getComment())) {
            properties.put("comment", val);
        }
        if (null != (val = toRemove.getDomain())) {
            properties.put("domain", val);
        }
        if (null != (val = toRemove.getMaxAge())) {
            properties.put("maxAge", val);
        }
        if (extContext.isSecure()) {
            properties.put("secure", Boolean.TRUE);
        } else if (null != (val = toRemove.getSecure())) {
            properties.put("secure", val);
        }
        if (null != (val = toRemove.getPath())) {
            properties.put("path", val);
        }
        properties.put("httpOnly", Boolean.TRUE);
        extContext.addResponseCookie(toRemove.getName(), toRemove.getValue(), 
                !properties.isEmpty() ? properties : null);
        properties = null;           
        
    }

    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Inner classes">

    private enum LifetimeMarker {

        // these must be unique
        
        FirstTimeThru("f"),
        SecondTimeThru("s"),
        IsRedirect("r"),
        IsNormal("n");

        private static char FIRST_TIME_THRU = 'f';
        private static char SECOND_TIME_THRU = 's';
        private static char IS_REDIRECT = 'r';
        private static char IS_NORMAL = 'n';

        private String name;

        private LifetimeMarker(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return name;
        }
        
        public char encode() {
            return name.charAt(0);
        }

        public static LifetimeMarker decode(char c) {
            LifetimeMarker result = FirstTimeThru;

            if (FIRST_TIME_THRU == c) {
                result = FirstTimeThru;
            } else if (SECOND_TIME_THRU == c) {
                result = SecondTimeThru;
            } else if (IS_REDIRECT == c) {
                result = IsRedirect;
            } else if (IS_NORMAL == c) {
                result = IsNormal;
            } else {
                throw new IllegalStateException("class invariant failed: invalid lifetime marker");
            }

            return result;
        }
                
    }

    private void releaseCurrentFlashManager(Map<Object, Object> contextMap) {
        contextMap.remove(CONSTANTS.RequestFlashManager);
    }

    /**
     * <p>Called when you need to get access to the flashManager.  If
     * argument create is true, and no instance of the FlashManager
     * exists for this request, create it and store it in the
     * contextMap.</p>
     */
    private PreviousNextFlashInfoManager getCurrentFlashManager(Map<Object, Object> contextMap,
            boolean create) {
        PreviousNextFlashInfoManager result = (PreviousNextFlashInfoManager)
                contextMap.get(CONSTANTS.RequestFlashManager);

        if (null == result && create) {
            result = new PreviousNextFlashInfoManager(guard, flashInnerMap);
            result.initializeBaseCase(this);
            contextMap.put(CONSTANTS.RequestFlashManager, result);

        }
        return result;
    }

    /**
     * <p>Called on the preRestoreView phase if the browser sent us a
     * cookie.  If no instance of the FlashManager exists for this
     * request, create it and store it in the contextMap.</p>
     */
    private PreviousNextFlashInfoManager getCurrentFlashManager(FacesContext context,
            Map<Object, Object> contextMap,
            Cookie cookie) {
        PreviousNextFlashInfoManager result = (PreviousNextFlashInfoManager)
                contextMap.get(CONSTANTS.RequestFlashManager);

        if (null == result) {
            result = new PreviousNextFlashInfoManager(guard, flashInnerMap);
            try {
                result.decode(context, this, cookie);
                contextMap.put(CONSTANTS.RequestFlashManager, result);
            } catch (InvalidKeyException ike) {
                contextMap.put(CONSTANTS.ForceSetMaxAgeZero, Boolean.TRUE);
                if (LOGGER.isLoggable(Level.SEVERE)) {
                    result = getCurrentFlashManager(contextMap, true);
                    LOGGER.log(Level.SEVERE,
                            "jsf.externalcontext.flash.bad.cookie",
                            new Object [] { ike.getMessage() });
                }
                
            }

        }
        return result;
    }

    /**
     * <p>On any given request, there are actually two maps behind the
     * flash.  Which one is actually used on a given Map method depends
     * on the current lifecycle phase at the time the method is invoked.
     * There is a "next" map, and a "previous" map.  This class manages
     * the complexities of dealing with these two maps, and does so by
     * relying on another inner class, FlashInfo.</p>

     * <p>The "next" map is used in only one case, which happens to be a
     * VERY common case: write operations to the flash that happen
     * during render response.</p>

     * <p>The "previous" map is used for write operations that happen
     * before render response, and for all read operations.</p>

     * <p>This class knows how to "decode" its state from an incoming
     * cookie, written by a previous call to "encode".</p>

     * <p>See the docs for FlashInfo for more information.</p>
     */

    private static final class PreviousNextFlashInfoManager {

        private FlashInfo previousRequestFlashInfo;

        private FlashInfo nextRequestFlashInfo;

        private boolean incomingCookieCameFromRedirect = false;

        private Map<String,Map<String, Object>> innerMap;
        
        private ByteArrayGuardAESCTR guard;

        private PreviousNextFlashInfoManager(ByteArrayGuardAESCTR guard) {
            this.guard = guard;
        }

        private PreviousNextFlashInfoManager(ByteArrayGuardAESCTR guard, Map<String,Map<String, Object>> innerMap) {
            this.guard = guard;
            this.innerMap = innerMap;
        }

        protected PreviousNextFlashInfoManager copyWithoutInnerMap() {
            PreviousNextFlashInfoManager result = new PreviousNextFlashInfoManager(guard);
            result.innerMap = Collections.emptyMap();
            if (null != previousRequestFlashInfo) {
                result.previousRequestFlashInfo = this.previousRequestFlashInfo.copyWithoutInnerMap();
            }
            if (null != nextRequestFlashInfo) {
                result.nextRequestFlashInfo = this.nextRequestFlashInfo.copyWithoutInnerMap();
            }
            result.incomingCookieCameFromRedirect = this.incomingCookieCameFromRedirect;

            return result;
        }



        @Override
        public String toString() {
            String result = null;

            result = "previousRequestSequenceNumber: " +
                    ((null != previousRequestFlashInfo) ? previousRequestFlashInfo.getSequenceNumber() : "null") +
                    " nextRequestSequenceNumber: " +
                    ((null != nextRequestFlashInfo) ? nextRequestFlashInfo.getSequenceNumber() : "null");

            return result;
        }

        void initializeBaseCase(ELFlash flash) {
            Map<String, Object> flashMap = null;

            previousRequestFlashInfo = new FlashInfo(flash.getNewSequenceNumber(),
                    LifetimeMarker.FirstTimeThru, false);
            innerMap.put(previousRequestFlashInfo.getSequenceNumber() + "",
                    flashMap = new HashMap<>());
            previousRequestFlashInfo.setFlashMap(flashMap);

            nextRequestFlashInfo = new FlashInfo(flash.getNewSequenceNumber(),
                    LifetimeMarker.FirstTimeThru, false);
            innerMap.put(nextRequestFlashInfo.getSequenceNumber() + "",
                    flashMap = new HashMap<>());
            nextRequestFlashInfo.setFlashMap(flashMap);
        }

        void expirePrevious() {
            // expire previous
            if (null != previousRequestFlashInfo) {
                Map<String, Object> flashMap;
                // clear the old map
                if (null != (flashMap = previousRequestFlashInfo.getFlashMap())) {
                    if (LOGGER.isLoggable(Level.FINEST)) {
                        LOGGER.log(Level.FINEST, "{0} expire previous[{1}]",
                                new Object[]{getLogPrefix(FacesContext.getCurrentInstance()),
                                    previousRequestFlashInfo.getSequenceNumber()});

                    }
                    FacesContext context = FacesContext.getCurrentInstance();
                    context.getApplication().publishEvent(context, PreClearFlashEvent.class, 
                            flashMap);
                    flashMap.clear();
                }
                // remove it from the flash
                innerMap.remove(previousRequestFlashInfo.getSequenceNumber() + "");
                previousRequestFlashInfo = null;
            }
        }

        void expireNext_MovePreviousToNext() {
            if (null != nextRequestFlashInfo) {
                if (LOGGER.isLoggable(Level.FINEST)) {
                    LOGGER.log(Level.FINEST, "{0} expire next[{1}], move previous to next",
                            new Object[]{getLogPrefix(FacesContext.getCurrentInstance()),
                                nextRequestFlashInfo.getSequenceNumber()});

                }
                Map<String, Object> flashMap = nextRequestFlashInfo.getFlashMap();
                                
                FacesContext context = FacesContext.getCurrentInstance();
                context.getApplication().publishEvent(context, PreClearFlashEvent.class, 
                        flashMap);
                
                // clear the old map
                flashMap.clear();
                // remove it from the flash
                innerMap.remove(nextRequestFlashInfo.getSequenceNumber() + "");
                nextRequestFlashInfo = null;
            }

            nextRequestFlashInfo = previousRequestFlashInfo;
            previousRequestFlashInfo = null;
        }

	/**
	 * <p>Decode the state of the PreviousNextFlashInfoManager from
	 * a Cookie.  This entire method is wrapped in a try-catch block
	 * to prevent any errors from malformed cookies from polluting
	 * the system.  When any error occurs, the flash is not usable
	 * for this request, and a nice error message is logged.</p>

	 * <p>This method is where the LifetimeMarker is incremented,
	 * UNLESS the incoming request is the GET after the REDIRECT
	 * after POST, in which case we don't increment it because the
	 * system will expire the entries in the doLastPhaseActions.</p>
	 *
	 */

        void decode(FacesContext context, ELFlash flash, Cookie cookie) throws InvalidKeyException {
            String temp;
            String value;
            
            String urlDecodedValue = null;
            
            try {
                urlDecodedValue = URLDecoder.decode(cookie.getValue(), "UTF-8");
            } catch (UnsupportedEncodingException uee) {
                urlDecodedValue = cookie.getValue();
            }
            
            value = guard.decrypt(urlDecodedValue);
            
            try {
                int i = value.indexOf("_");

                // IMPORTANT: what was "next" when the cookie was
                // encoded is now "previous".  Therefore decode "next" first.
                temp = value.substring(0, i++);

                if (0 < temp.length()) {
                    nextRequestFlashInfo = new FlashInfo();
                    nextRequestFlashInfo.decode(temp);
                }
                // invariant we must always have something after the _
                previousRequestFlashInfo = new FlashInfo();
                previousRequestFlashInfo.decode(value.substring(i));

		// handle the consequences of action taken on doLastPhaseActions
                if (previousRequestFlashInfo.isIsRedirect()) {
                    this.setIncomingCookieCameFromRedirect(true);
                    previousRequestFlashInfo.setIsRedirect(false);
                } else {
                    // Don't make the flash older on debug requests
                    if (!UIDebug.debugRequest(context)) {
                        previousRequestFlashInfo.setLifetimeMarker(LifetimeMarker.SecondTimeThru);
                        nextRequestFlashInfo = null;
                    }
                }
                Map<String, Object> flashMap;
                // If the browser sent a cookie that is valid, but
                // doesn't correspond to a map in memory...
                if (null == (flashMap = innerMap.get(previousRequestFlashInfo.getSequenceNumber() + ""))) {
                    // create a new map
                    previousRequestFlashInfo = new FlashInfo();
                    previousRequestFlashInfo.setSequenceNumber(flash.getNewSequenceNumber());
                    previousRequestFlashInfo.setLifetimeMarker(LifetimeMarker.FirstTimeThru);
                    previousRequestFlashInfo.setIsRedirect(false);
                    // put it in the flash
                    innerMap.put(previousRequestFlashInfo.getSequenceNumber() + "",
                            flashMap = new HashMap<>());
                }
                previousRequestFlashInfo.setFlashMap(flashMap);
                if (null != nextRequestFlashInfo) {
                    if (null == (flashMap = innerMap.get(nextRequestFlashInfo.getSequenceNumber() + ""))) {
                        // create a new map
                        nextRequestFlashInfo = new FlashInfo();
                        nextRequestFlashInfo.setSequenceNumber(flash.getNewSequenceNumber());
                        nextRequestFlashInfo.setLifetimeMarker(LifetimeMarker.FirstTimeThru);
                        nextRequestFlashInfo.setIsRedirect(false);
                        // put it in the flash
                        innerMap.put(nextRequestFlashInfo.getSequenceNumber() + "",
                                flashMap = new HashMap<>());
                    }
                    nextRequestFlashInfo.setFlashMap(flashMap);
                }
            } catch (Throwable t) {
                context.getAttributes().put(CONSTANTS.ForceSetMaxAgeZero, Boolean.TRUE);
                if (LOGGER.isLoggable(Level.SEVERE)) {
                    LOGGER.log(Level.SEVERE,
                            "jsf.externalcontext.flash.bad.cookie",
                            new Object [] { value });
                }
            }

        }

	/**
	 * <p>Encode the current state of the
	 * PreviousNextFlashInfoManager to the cookie.</p>
	 */
        Cookie encode() {
            Cookie result = null;

            String value = ((null != previousRequestFlashInfo) ? previousRequestFlashInfo.encode() : "")  + "_" +
                           ((null != nextRequestFlashInfo) ? nextRequestFlashInfo.encode() : "");
            String encryptedValue = guard.encrypt(value);
            try {
                result = new Cookie(FLASH_COOKIE_NAME, URLEncoder.encode(encryptedValue, "UTF-8"));
            } catch (UnsupportedEncodingException uee) {
                result = new Cookie(FLASH_COOKIE_NAME, encryptedValue);
            }
                
            if (1 == value.length()) {
                result.setMaxAge(0);
            }            
            String requestContextPath = FacesContext.getCurrentInstance().getExternalContext().getRequestContextPath();
            if (requestContextPath.isEmpty()) {
                requestContextPath = "/";
            }
            result.setPath(requestContextPath);
            return result;
        }

        FlashInfo getPreviousRequestFlashInfo() {
            return previousRequestFlashInfo;
        }

        void setPreviousRequestFlashInfo(FlashInfo thisRequestFlashInfo) {
            this.previousRequestFlashInfo = thisRequestFlashInfo;
        }

        FlashInfo getNextRequestFlashInfo() {
            return nextRequestFlashInfo;
        }

        FlashInfo getNextRequestFlashInfo(ELFlash flash, boolean create) {
            if (create && null == nextRequestFlashInfo) {
                nextRequestFlashInfo = new FlashInfo();
                nextRequestFlashInfo.setSequenceNumber(flash.getNewSequenceNumber());
                nextRequestFlashInfo.setLifetimeMarker(LifetimeMarker.FirstTimeThru);
                nextRequestFlashInfo.setIsRedirect(false);
                // put it in the flash
                Map<String, Object> flashMap = null;
                innerMap.put(nextRequestFlashInfo.getSequenceNumber() + "",
                        flashMap = new HashMap<>());
                nextRequestFlashInfo.setFlashMap(flashMap);
            }
            return nextRequestFlashInfo;
        }

        void setNextRequestFlashInfo(FlashInfo nextRequestFlashInfo) {
            this.nextRequestFlashInfo = nextRequestFlashInfo;
        }

        boolean isIncomingCookieCameFromRedirect() {
            return incomingCookieCameFromRedirect;
        }

        void setIncomingCookieCameFromRedirect(boolean incomingCookieCameFromRedirect) {
            this.incomingCookieCameFromRedirect = incomingCookieCameFromRedirect;
        }

    }

    /**
     * <p>Encapsulate one of the two maps that back the flash for the
     * current request.</p>
     */
    private static final class FlashInfo {

	/**
	 * <p>Set to true by the Flash when the extContext tells us
	 * there is a redirect.</p>
	 */
        private boolean isRedirect;

	/**
	 * <p>How many times has this map been through the lifecycle?</p>
	 */
        private LifetimeMarker lifetimeMarker;

	/**
	 * <p>Application Unique key in the innerMap.</p>
	 */

        private long sequenceNumber;

	/**
	 * <p>The Map that stores the data. This map itself is stored in
	 * innerMap under the key given by the value of
	 * sequenceNumber.</p>
	 */
        private Map<String, Object> flashMap;

        private FlashInfo() {

        }

        FlashInfo(long sequenceNumber, LifetimeMarker lifetimeMarker,
                boolean isRedirect) {
            setSequenceNumber(sequenceNumber);
            setLifetimeMarker(lifetimeMarker);
            setIsRedirect(isRedirect);
        }

        FlashInfo copyWithoutInnerMap()  {
            FlashInfo result = new FlashInfo(this.sequenceNumber, 
                    this.lifetimeMarker, this.isRedirect);

            return result;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final FlashInfo other = (FlashInfo) obj;
            if (this.isRedirect != other.isRedirect) {
                return false;
            }
            if (this.lifetimeMarker != other.lifetimeMarker && (this.lifetimeMarker == null || !this.lifetimeMarker.equals(other.lifetimeMarker))) {
                return false;
            }
            if (this.sequenceNumber != other.sequenceNumber) {
                return false;
            }
            return true;
        }

        @Override
        public int hashCode() {
            int hash = 7;
            hash = 71 * hash + (this.isRedirect ? 1 : 0);
            hash = 71 * hash + (this.lifetimeMarker != null ? this.lifetimeMarker.hashCode() : 0);
            hash = 71 * hash + (int) (this.sequenceNumber ^ (this.sequenceNumber >>> 32));
            return hash;
        }

        

        void decode(String value) {
            if (null == value || 0 == value.length()) {

                // PENDING(edburns): REMOVE THIS
                return;
            }

            int i = value.indexOf('X');

            // decode the sequence number
            setSequenceNumber(Long.parseLong(value.substring(0, i++)));

            // decode the lifetime marker
            setLifetimeMarker(LifetimeMarker.decode(value.charAt(i++)));
            
            // decode the redirect flag
            setIsRedirect(LifetimeMarker.IsRedirect ==
                    LifetimeMarker.decode(value.charAt(i++)));
        }

        String encode() {
            String value = null;

            // The cookie value is an encoding of the sequence number, the
            // lifetime marker, and the redirect flag
            if (isIsRedirect()) {
                value = Long.toString(getSequenceNumber()) + "X" +
                        getLifetimeMarker().encode() +
                        LifetimeMarker.IsRedirect.encode();
            } else {
                value = Long.toString(getSequenceNumber()) + "X" +
                        getLifetimeMarker().encode() +
                        LifetimeMarker.IsNormal.encode();
            }

            return value;
        }

        boolean isIsRedirect() {
            return isRedirect;
        }

        void setIsRedirect(boolean isRedirect) {
            this.isRedirect = isRedirect;
        }

        long getSequenceNumber() {
            return sequenceNumber;
        }

        void setSequenceNumber(long sequenceNumber) {
            this.sequenceNumber = sequenceNumber;
        }

        LifetimeMarker getLifetimeMarker() {
            return lifetimeMarker;
        }

        void setLifetimeMarker(LifetimeMarker lifetimeMarker) {
            this.lifetimeMarker = lifetimeMarker;
        }

        Map<String, Object> getFlashMap() {
            return flashMap;
        }

        void setFlashMap(Map<String, Object> flashMap) {
            this.flashMap = flashMap;
        }

        

    }

    // </editor-fold>


}