/*

    * 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.wicket;

  import java.io.Serializable;

  import java.util.Collection;

  import java.util.Iterator;

  import java.util.Map;

  import java.util.Map.Entry;

  import org.apache.wicket.behavior.IBehavior;

  import org.apache.wicket.protocol.http.BufferedWebResponse;

  import org.apache.wicket.protocol.http.IRequestLogger;

  import org.apache.wicket.protocol.http.PageExpiredException;

  import org.apache.wicket.protocol.http.WicketURLEncoder;

  import org.apache.wicket.protocol.http.servlet.ServletWebRequest;

  import org.apache.wicket.request.AbstractRequestCycleProcessor;

  import org.apache.wicket.request.ClientInfo;

  import org.apache.wicket.request.IRequestCycleProcessor;

  import org.apache.wicket.request.RequestParameters;

  import org.apache.wicket.request.target.component.BookmarkableListenerInterfaceRequestTarget;

  import org.apache.wicket.request.target.component.BookmarkablePageRequestTarget;

  import org.apache.wicket.request.target.component.ComponentRequestTarget;

  import org.apache.wicket.request.target.component.IBookmarkablePageRequestTarget;

  import org.apache.wicket.request.target.component.IPageRequestTarget;

  import org.apache.wicket.request.target.component.PageRequestTarget;

  import org.apache.wicket.request.target.component.listener.BehaviorRequestTarget;

  import org.apache.wicket.request.target.component.listener.ListenerInterfaceRequestTarget;

  import org.apache.wicket.request.target.resource.SharedResourceRequestTarget;

  import org.apache.wicket.util.collections.ArrayListStack;

  import org.apache.wicket.util.string.AppendingStringBuffer;

  import org.apache.wicket.util.string.Strings;

  import org.apache.wicket.util.time.Time;

  import org.apache.wicket.util.value.ValueMap;

  import org.slf4j.Logger;

  import org.slf4j.LoggerFactory;

 public abstract class RequestCycle

 {
	

 	private static final ThreadLocal current = new ThreadLocal();

	

 	private static final int DETACH_REQUEST = 5;

	

 	private static final int DONE = 6;

	

 	private static final Logger log = LoggerFactory.getLogger(RequestCycle.class);

	

 	private static final int NOT_STARTED = 0;

	

 	private static final int PREPARE_REQUEST = 1;

	

 	private static final int PROCESS_EVENTS = 3;

	

 	private static final int RESOLVE_TARGET = 2;

	

 	private static final int RESPOND = 4;

	

 	public static RequestCycle get()

 	{

 		return (RequestCycle)current.get();

 	}

	

 	protected static void set(RequestCycle cycle)

 	{

 		current.set(cycle);

 	}

 	private RequestCycle previousOne = null;

	

 	private boolean automaticallyClearFeedbackMessages = true;

	

 	private int currentStep = NOT_STARTED;

 	private boolean handlingException = false;

	

 	private final Response originalResponse;

	

 	private boolean redirect;

	

 	private transient final ArrayListStack requestTargets = new ArrayListStack(3)

 	{

 		private static final long serialVersionUID = 1L;

 		public void add(int arg0, Object arg1)

 		{

 			onRequestTargetSet((IRequestTarget)arg1);

 			super.add(arg0, arg1);

 		}

 		public boolean add(Object arg0)

 		{

 			onRequestTargetSet((IRequestTarget)arg0);

 			return super.add(arg0);

 		}

 		public boolean addAll(Collection arg0)

 		{

 			Iterator it = arg0.iterator();

 			while (it.hasNext())

 			{

 				onRequestTargetSet((IRequestTarget)it.next());

 			}

 			return super.addAll(arg0);

 		}

 		public boolean addAll(int arg0, Collection arg1)

 		{

 			Iterator it = arg1.iterator();

 			while (it.hasNext())

 			{

 				onRequestTargetSet((IRequestTarget)it.next());

 			}

 			return super.addAll(arg0, arg1);

 		}

 	};

	

 	private PageParameters pageParameters;

	

 	private Session session;

	

 	private final long startTime = System.currentTimeMillis();

	

 	protected final Application application;

	

 	protected final IRequestCycleProcessor processor;

	

 	protected Request request;

	

 	protected Response response;

	

 	private transient boolean urlForNewWindowEncoding;

	

 	protected RequestCycle(final Application application, final Request request,

 		final Response response)

 	{

 		this.application = application;

 		this.request = request;

 		this.response = response;

 		originalResponse = response;

 		processor = safeGetRequestProcessor();

 		previousOne = (RequestCycle)current.get();

 		// Set this RequestCycle into ThreadLocal variable

 		current.set(this);

 	}

	

 	public final Application getApplication()

 	{

 		return application;

 	}

	

 	public final ClientInfo getClientInfo()

 	{

 		return getSession().getClientInfo();

 	}

	

 	public final Response getOriginalResponse()

 	{

 		return originalResponse;

 	}

	

 	public final PageParameters getPageParameters()

 	{

 		return pageParameters;

 	}

	

 	public abstract IRequestCycleProcessor getProcessor();

	

 	public final boolean getRedirect()

 	{

 		return isRedirect();

 	}

	

 	public final Request getRequest()

 	{

 		return request;

 	}

	

 	public final IRequestTarget getRequestTarget()

 	{

 		return (!requestTargets.isEmpty()) ? (IRequestTarget)requestTargets.peek() : null;

 	}

	

 	public final Response getResponse()

 	{

 		return response;

 	}

	

 	public final Page getResponsePage()

 	{

 		IRequestTarget target = getRequestTarget();

 		if (target instanceof IPageRequestTarget)

 		{

 			return ((IPageRequestTarget)target).getPage();

 		}

 		else if (target instanceof BookmarkablePageRequestTarget)

 		{

 			return ((BookmarkablePageRequestTarget)target).getPage();

 		}

 		return null;

 	}

	

 	public final Class getResponsePageClass()

 	{

 		IRequestTarget target = getRequestTarget();

 		if (target != null && (target instanceof IBookmarkablePageRequestTarget))

 		{

 			return ((IBookmarkablePageRequestTarget)target).getPageClass();

 		}

 		return null;

 	}

	

 	public final Session getSession()

 	{

 		if (session == null)

 		{

 			session = Session.get();

 		}

 		return session;

 	}

	

 	public final long getStartTime()

 	{

 		return startTime;

 	}

	

 	public boolean isRedirect()

 	{

 		return redirect;

 	}

	

 	public Page onRuntimeException(Page page, RuntimeException e)

 	{

 		return null;

 	}

	

 	public abstract void redirectTo(final Page page);

	

 	public final void request()

 	{

 		checkReuse();

 		// set start step

 		currentStep = PREPARE_REQUEST;

 		// loop through steps

 		steps();

 	}

	

 	public final void request(final Component component)

 	{

 		checkReuse();

 		if (component.isAuto())

 		{

 			throw new WicketRuntimeException("Auto-added components can not be re-rendered");

 		}

 		request(new ComponentRequestTarget(component));

 	}

	

 	public final void request(IRequestTarget target)

 	{

 		checkReuse();

 		// set it as the current target, on the top of the stack

 		requestTargets.push(target);

 		// set start step

 		currentStep = PROCESS_EVENTS;

 		// loop through steps

 		steps();

 	}

	

 	public void setAutomaticallyClearFeedbackMessages(boolean automaticallyClearFeedbackMessages)

 	{

 		// FIXME This method is a quick fix for a unit testing problem that

 		// should not exist

 		this.automaticallyClearFeedbackMessages = automaticallyClearFeedbackMessages;

 	}

	

 	public final void setRedirect(final boolean redirect)

 	{

 		this.redirect = redirect;

 	}

	

 	public final void setRequest(Request request)

 	{

 		this.request = request;

 	}

	

 	public final void setRequestTarget(IRequestTarget requestTarget)

 	{

 		if (log.isDebugEnabled())

 		{

 			if (!requestTargets.isEmpty())

 			{

 				IRequestTarget former = (IRequestTarget)requestTargets.peek();

 				log.debug("replacing request target " + former + " with " + requestTarget);

 			}

 			else

 			{

 				log.debug("setting request target to " + requestTarget);

 			}

 		}

 		// change the current step to a step that will handle the

 		// new target if need be

 		if (currentStep >= RESPOND)

 		{

 			if (log.isDebugEnabled())

 			{

 				log.debug("rewinding request processing to PROCESS_EVENTS");

 			}

 			// we are not actually doing event processing again,

 			// but since we are still in the loop here, the next

 			// actual value will be RESPOND again

 			currentStep = PROCESS_EVENTS;

 		}

 		// NOTE: if we are at PROCESS_EVENTS, leave it as we don't

 		// want to re-execute that step again

 		requestTargets.push(requestTarget);

 	}

	

 	protected void onRequestTargetSet(IRequestTarget requestTarget)

 	{

 	}

	

 	public final Response setResponse(final Response response)

 	{

 		final Response orig = this.response;

 		this.response = response;

 		return orig;

 	}

	

 	private String getCurrentPageMap()

 	{

 		IRequestTarget target = RequestCycle.get().getRequestTarget();

 		if (target instanceof IPageRequestTarget)

 		{

 			Page page = ((IPageRequestTarget)target).getPage();

 			return page != null ? page.getPageMapName() : null;

 		}

 		else if (target instanceof IBookmarkablePageRequestTarget)

 		{

 			return ((IBookmarkablePageRequestTarget)target).getPageMapName();

 		}

 		else

 		{

 			return null;

 		}

 	}

	

 	public final void setResponsePage(final Class pageClass)

 	{

 		setResponsePage(pageClass, null);

 	}

	

 	public final void setResponsePage(final Class pageClass, final PageParameters pageParameters)

 	{

 		setResponsePage(pageClass, pageParameters, getCurrentPageMap());

 	}

	

 	public final void setResponsePage(final Class pageClass, final PageParameters pageParameters,

 		final String pageMapName)

 	{

 		IRequestTarget target = new BookmarkablePageRequestTarget(pageMapName, pageClass,

 			pageParameters);

 		setRequestTarget(target);

 	}

	

 	public final void setResponsePage(final Page page)

 	{

 		IRequestTarget target = new PageRequestTarget(page);

 		setRequestTarget(target);

 	}

	

 	public String toString()

 	{

 		return "[RequestCycle" + "@" + Integer.toHexString(hashCode()) + " thread=" +

 			Thread.currentThread().getName() + "]";

 	}

	

 	public final boolean isUrlForNewWindowEncoding()

 	{

 		return urlForNewWindowEncoding;

 	}

	

 	public final void setUrlForNewWindowEncoding()

 	{

 		urlForNewWindowEncoding = true;

 	}

	

 	private final CharSequence encodeUrlFor(final IRequestTarget requestTarget)

 	{

 		CharSequence url = getProcessor().getRequestCodingStrategy().encode(this, requestTarget);

 		urlForNewWindowEncoding = false;

 		return url;

 	}

	

 	public final CharSequence urlFor(final Class pageClass, final PageParameters parameters)

 	{

 		return urlFor(null, pageClass, parameters);

 	}

	

 	public final CharSequence urlFor(final Component component, final IBehavior behaviour,

 		final RequestListenerInterface listener)

 	{

 		int index = component.getBehaviorsRawList().indexOf(behaviour);

 		if (index == -1)

 		{

 			throw new IllegalArgumentException("Behavior " + this +

 				" was not registered with this component: " + component.toString());

 		}

 		RequestParameters params = new RequestParameters();

 		params.setBehaviorId(String.valueOf(index));

 		if (request instanceof ServletWebRequest)

 		{

 			ServletWebRequest swr = (ServletWebRequest)request;

 			// If we're coming in with an existing depth, use it. Otherwise,

 			// compute from the URL. This provides correct behavior for repeated

 			// AJAX requests: If we need to generate a URL within an AJAX

 			// request for another one, it needs to be at the same depth as the

 			// original AJAX request.

 			int urlDepth = swr.getRequestParameters().getUrlDepth();

 			params.setUrlDepth(urlDepth > -1 ? urlDepth : swr.getDepthRelativeToWicketHandler());

 		}

 		final IRequestTarget target = new BehaviorRequestTarget(component.getPage(), component,

 			listener, params);

 		return encodeUrlFor(target);

 	}

	

 	public final CharSequence urlFor(final Component component,

 		final RequestListenerInterface listener, ValueMap params)

 	{

 		// Get Page holding component and mark it as stateful.

 		final Page page = component.getPage();

 		final IRequestTarget target;

 		if (listener != IRedirectListener.INTERFACE && component.isStateless() &&

 			page.isBookmarkable() && page.getStatelessHint())

 		{

 			PageParameters pageParameters = page.getPageParameters();

 			if (pageParameters == null)

 			{

 				pageParameters = new PageParameters();

 			}

 			else

 			{

 				pageParameters = (PageParameters)pageParameters.clone();

 			}

 			if (params != null)

 			{

 				Iterator it = params.entrySet().iterator();

 				while (it.hasNext())

 				{

 					final Map.Entry entry = (Entry)it.next();

 					final String key = entry.getKey().toString();

 					final String value = entry.getValue().toString();

 					// Do not encode values here. It is the encoder's job

 					// to do the endoding. This leads to double encoding

 					// - Doug Donohoe

 					// @see https://issues.apache.org/jira/browse/WICKET-1627

 					// pageParameters.add(encodeQueryStringItem(key), encodeQueryStringItem(value));

 					pageParameters.add(key, value);

 				}

 			}

 			target = new BookmarkableListenerInterfaceRequestTarget(page.getPageMapName(),

 				page.getClass(), pageParameters, component, listener);

 			return encodeUrlFor(target);

 		}

 		else

 		{

 			page.setPageStateless(Boolean.FALSE);

 			// make session non-volatile if not already so

 			final Session session = getSession();

 			if (session.isTemporary())

 			{

 				session.bind();

 			}

 			// Get the listener interface name

 			target = new ListenerInterfaceRequestTarget(page, component, listener);

 			CharSequence url = encodeUrlFor(target);

 			if (params != null)

 			{

 				AppendingStringBuffer buff = new AppendingStringBuffer(url);

 				Iterator it = params.entrySet().iterator();

 				while (it.hasNext())

 				{

 					final Map.Entry entry = (Entry)it.next();

 					final String key = entry.getKey().toString();

 					final String value = entry.getValue().toString();

 					buff.append("&");

 					buff.append(encodeQueryStringItem(key));

 					buff.append("=");

 					buff.append(encodeQueryStringItem(value));

 				}

 				url = buff;

 			}

 			return url;

 		}

 	}

	

 	private static String encodeQueryStringItem(String value)

 	{

 		return WicketURLEncoder.QUERY_INSTANCE.encode(value);

 	}

	

 	public final CharSequence urlFor(final Component component,

 		final RequestListenerInterface listener)

 	{

 		return urlFor(component, listener, null);

 	}

	

 	public final CharSequence urlFor(final IPageMap pageMap, final Class pageClass,