/*

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

 import java.io.InputStream;

 import java.io.OutputStream;

 import java.net.SocketException;

 import java.net.URLConnection;

 import java.sql.SQLException;

 import java.util.List;

 import java.util.Locale;

 import javax.servlet.ServletContext;

 import org.apache.wicket.markup.ComponentTag;

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

 import org.apache.wicket.util.io.Streams;

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

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

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

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 public abstract class Response

 {

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

	

 	private String defaultEncoding;

	

 	public void close()

 	{

 	}

	

 	public void reset()

 	{

 	}

	

 	public CharSequence encodeURL(final CharSequence url)

 	{

 		return url;

 	}

	

 	public final AppendingStringBuffer filter(AppendingStringBuffer responseBuffer)

 	{

 		List responseFilters = Application.get().getRequestCycleSettings().getResponseFilters();

 		if (responseFilters == null)

 		{

 			return responseBuffer;

		}

		for (int i = 0; i < responseFilters.size(); i++)

		{

			IResponseFilter filter = (IResponseFilter)responseFilters.get(i);

			responseBuffer = filter.filter(responseBuffer);

		}

		return responseBuffer;

	}

	

	public String getCharacterEncoding()

	{

		if (defaultEncoding == null)

		{

			return Application.get().getRequestCycleSettings().getResponseRequestEncoding();

		}

		else

		{

			return defaultEncoding;

		}

	}

	

	public abstract OutputStream getOutputStream();

	

	public boolean isRedirect()

	{

		return false;

	}

	

	public void redirect(final String url)

	{

	}

	

	public void setCharacterEncoding(final String encoding)

	{

		defaultEncoding = encoding;

	}

	

	public void setContentLength(final long length)

	{

	}

	

	public void setContentType(final String mimeType)

	{

	}

	

	public void setLastModifiedTime(Time time)

	{

	}

	

	public void setLocale(final Locale locale)

	{

	}

	

	public final void write(final ComponentTag tag)

	{

		write(tag.toString());

	}

	

	public abstract void write(final CharSequence string);

	

	private void handleException(Exception e)

	{

		// FIXME this doesn't catch all. For instance, Jetty (6/ NIO) on

		// Unix like platforms will not be recognized as exceptions

		// that should be ignored

		Throwable throwable = e;

		boolean ignoreException = false;

		while (throwable != null)

		{

			if (throwable instanceof SQLException)

			{

				break; // leave false and quit loop

			}

			else if (throwable instanceof SocketException)

			{

				String message = throwable.getMessage();

				ignoreException = message != null &&

					(message.indexOf("Connection reset") != -1 ||

						message.indexOf("Broken pipe") != -1 ||

						message.indexOf("Socket closed") != -1 || message.indexOf("connection abort") != -1);

			}

			else

			{

				ignoreException = throwable.getClass().getName().indexOf("ClientAbortException") >= 0 ||

					throwable.getClass().getName().indexOf("EofException") >= 0;

			}

			if (ignoreException)

			{

				if (log.isDebugEnabled())

				{

					log.debug("Socket exception ignored for sending Resource "

						+ "response to client (ClientAbort)", e);

				}

				break;

			}

			throwable = throwable.getCause();

		}

		if (!ignoreException)

		{

			throw new WicketRuntimeException("Unable to write the response", e);

		}

	}

	

	public void write(InputStream in)

	{

		OutputStream out = getOutputStream();

		try

		{

			// Copy resource input stream to servlet output stream

			Streams.copy(in, out);

		}

		catch (Exception e)

		{

			handleException(e);

		}

		finally

		{

			// NOTE: We only close the InputStream. The servlet

			// container should close the output stream.

			try

			{

				in.close();

				out.flush();

			}

			catch (IOException e)

			{

				// jetty 6 throws broken pipe exception here too

				handleException(e);

			}

		}

	}

	

	public final void println(final CharSequence string)

	{

		write(string);

		write(Strings.LINE_SEPARATOR);

	}

	

	public void detectContentType(RequestCycle requestCycle, String uri)

	{

		// Configure response with content type of resource

		final ServletContext context = ((WebApplication)requestCycle.getApplication()).getServletContext();

		// First look for user defined content-type in web.xml

		String contentType = context.getMimeType(uri);

		// If not found, fall back to

		// FileResourceStream.getContentType() that looks into

		// system or JVM content types

		if (contentType == null)

		{

			contentType = URLConnection.getFileNameMap().getContentTypeFor(uri);

		}

		if (contentType != null)

		{

			// only set the charset when the contentType is the text type

			if (contentType.toLowerCase().indexOf("text") != -1)

			{

				setContentType(contentType + "; charset=" + getCharacterEncoding());

			}

			else

			{

				setContentType(contentType);

			}

		}

	}

}