/*

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

  import java.net.URL;

  import java.util.ArrayList;

  import java.util.Collections;

  import java.util.Enumeration;

  import java.util.HashMap;

  import java.util.Iterator;

  import java.util.List;

  import java.util.Map;

  import java.util.Properties;

  import java.util.Set;

  import org.apache.wicket.application.IComponentInstantiationListener;

  import org.apache.wicket.application.IComponentOnAfterRenderListener;

  import org.apache.wicket.application.IComponentOnBeforeRenderListener;

  import org.apache.wicket.markup.IMarkupCache;

  import org.apache.wicket.markup.html.IHeaderContributor;

  import org.apache.wicket.markup.html.IHeaderResponse;

  import org.apache.wicket.markup.html.image.resource.DefaultButtonImageResourceFactory;

  import org.apache.wicket.markup.parser.filter.RelativePathPrefixHandler;

  import org.apache.wicket.markup.parser.filter.WicketMessageTagHandler;

  import org.apache.wicket.markup.resolver.AutoComponentResolver;

  import org.apache.wicket.markup.resolver.BorderBodyResolver;

  import org.apache.wicket.markup.resolver.EnclosureResolver;

  import org.apache.wicket.markup.resolver.FragmentResolver;

  import org.apache.wicket.markup.resolver.HtmlHeaderResolver;

  import org.apache.wicket.markup.resolver.MarkupInheritanceResolver;

  import org.apache.wicket.markup.resolver.ParentResolver;

  import org.apache.wicket.markup.resolver.WicketContainerResolver;

  import org.apache.wicket.markup.resolver.WicketLinkResolver;

  import org.apache.wicket.markup.resolver.WicketMessageResolver;

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

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

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

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

  import org.apache.wicket.session.ISessionStore;

  import org.apache.wicket.settings.IApplicationSettings;

  import org.apache.wicket.settings.IDebugSettings;

  import org.apache.wicket.settings.IExceptionSettings;

  import org.apache.wicket.settings.IFrameworkSettings;

  import org.apache.wicket.settings.IMarkupSettings;

  import org.apache.wicket.settings.IPageSettings;

  import org.apache.wicket.settings.IRequestCycleSettings;

  import org.apache.wicket.settings.IRequestLoggerSettings;

  import org.apache.wicket.settings.IResourceSettings;

  import org.apache.wicket.settings.ISecuritySettings;

  import org.apache.wicket.settings.ISessionSettings;

  import org.apache.wicket.settings.Settings;

  import org.apache.wicket.util.convert.ConverterLocator;

  import org.apache.wicket.util.lang.Classes;

  import org.apache.wicket.util.lang.Objects;

  import org.apache.wicket.util.lang.PropertyResolver;

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

  import org.slf4j.Logger;

  import org.slf4j.LoggerFactory;

 public abstract class Application

 {
	

 	public static final String CONFIGURATION = "configuration";

	

 	public static final String CONTEXTPATH = "contextpath";

	

 	public static final String DEPLOYMENT = "deployment";

	

 	public static final String DEVELOPMENT = "development";

	

 	private static final Map applicationKeyToApplication = new HashMap(1);

	

 	private static final ThreadLocal current = new ThreadLocal();

	

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

	

 	public static boolean exists()

 	{

 		return current.get() != null;

 	}

	

 	public static Application get()

 	{

 		final Application application = (Application)current.get();

 		if (application == null)

 		{

 			throw new WicketRuntimeException("There is no application attached to current thread " +

 				Thread.currentThread().getName());

 		}

 		return application;

 	}

	

 	public static Application get(String applicationKey)

 	{

 		Application application = (Application)applicationKeyToApplication.get(applicationKey);

 		return application;

 	}

	

 	public static Set/* <String> */getApplicationKeys()

 	{

 		return Collections.unmodifiableSet(applicationKeyToApplication.keySet());

 	}

	

 	public static void set(final Application application)

 	{

 		if (application == null)

 		{

 			throw new IllegalArgumentException("Argument application can not be null");

 		}

 		current.set(application);

 	}

	

 	public static void unset()

 	{

 		current.set(null);

 	}

	

 	private IComponentInstantiationListener[] componentInstantiationListeners = new IComponentInstantiationListener[0];

	

 	private IConverterLocator converterLocator;

	

 	private final List initializers = new ArrayList();

	

 	private MetaDataEntry[] metaData;

	

 	private final String name;

	

 	private IRequestLogger requestLogger;

	

 	private ISessionStore sessionStore;

	

 	private Settings settings;

	

 	private boolean settingsAccessible;

	

 	private final SharedResources sharedResources;

	

 	public Application()

 	{

 		// Create name from subclass

 		name = Classes.simpleName(getClass());

 		// Create shared resources repository

 		sharedResources = new SharedResources(this);

 		// Install default component instantiation listener that uses

 		// authorization strategy to check component instantiations.

 		addComponentInstantiationListener(new IComponentInstantiationListener()

 		{
			

 			public void onInstantiation(final Component component)

 			{

 				// If component instantiation is not authorized

 				if (!Session.get().getAuthorizationStrategy().isInstantiationAuthorized(

 					component.getClass()))

 				{

 					// then call any unauthorized component instantiation

 					// listener

 					getSecuritySettings().getUnauthorizedComponentInstantiationListener()

 						.onUnauthorizedInstantiation(component);

 				}

 			}

 		});

 	}

	

 	public final void addComponentInstantiationListener(

 		final IComponentInstantiationListener listener)

 	{

 		if (listener == null)

 		{

 			throw new IllegalArgumentException("argument listener may not be null");

 		}

 		// if an instance of this listener is already present ignore this call

 		for (int i = 0; i < componentInstantiationListeners.length; i++)

 		{

 			if (listener == componentInstantiationListeners[i])

 			{

 				return;

 			}

 		}

 		final IComponentInstantiationListener[] newListeners = new IComponentInstantiationListener[componentInstantiationListeners.length + 1];

 		System.arraycopy(componentInstantiationListeners, 0, newListeners, 0,

 			componentInstantiationListeners.length);

 		newListeners[componentInstantiationListeners.length] = listener;

 		componentInstantiationListeners = newListeners;

 	}

	

 	public final void configure()

 	{

 		final String configurationType = getConfigurationType();

 		// As long as this is public api the development and deployment mode

 		// should counter act each other for all properties.

 		if (DEVELOPMENT.equalsIgnoreCase(configurationType))

 		{

 			getResourceSettings().setResourcePollFrequency(Duration.ONE_SECOND);

 			getDebugSettings().setComponentUseCheck(true);

 			getMarkupSettings().setStripWicketTags(false);

 			getExceptionSettings().setUnexpectedExceptionDisplay(

 				IExceptionSettings.SHOW_EXCEPTION_PAGE);

 			getDebugSettings().setAjaxDebugModeEnabled(true);

 			getResourceSettings().setStripJavascriptCommentsAndWhitespace(false);

 		}

 		else if (DEPLOYMENT.equalsIgnoreCase(configurationType))

 		{

 			getResourceSettings().setResourcePollFrequency(null);

 			getDebugSettings().setComponentUseCheck(false);

 			getMarkupSettings().setStripWicketTags(true);

 			getExceptionSettings().setUnexpectedExceptionDisplay(

 				IExceptionSettings.SHOW_INTERNAL_ERROR_PAGE);

 			getDebugSettings().setAjaxDebugModeEnabled(false);

 			getResourceSettings().setStripJavascriptCommentsAndWhitespace(true);

 		}

 		else

 		{

 			throw new IllegalArgumentException("Invalid configuration type: '" + configurationType +

 				"'.  Must be \"development\" or \"deployment\".");

 		}

 	}

	

 	public abstract String getApplicationKey();

	

 	public IApplicationSettings getApplicationSettings()

 	{

 		return getSettings();

 	}

	

 	public abstract String getConfigurationType();

	

 	public final IConverterLocator getConverterLocator()

 	{

 		return converterLocator;

 	}

	

 	public IDebugSettings getDebugSettings()

 	{

 		return getSettings();

 	}

	

 	public IExceptionSettings getExceptionSettings()

 	{

 		return getSettings();

 	}

	

 	public IFrameworkSettings getFrameworkSettings()

 	{

 		return getSettings();

 	}

	

 	public abstract Class getHomePage();

	

 	public final IMarkupCache getMarkupCache()

 	{

 		return getMarkupSettings().getMarkupCache();

 	}

	

 	public IMarkupSettings getMarkupSettings()

 	{

 		return getSettings();

 	}

	

 	public final Serializable getMetaData(final MetaDataKey key)

 	{

 		return (Serializable)key.get(metaData);

 	}

	

 	public final String getName()

 	{

 		return name;

 	}

	

 	public IPageSettings getPageSettings()

 	{

 		return getSettings();

 	}

	

 	public IRequestCycleSettings getRequestCycleSettings()

 	{

 		return getSettings();

 	}

	

 	public final IRequestLogger getRequestLogger()

 	{

 		if (getRequestLoggerSettings().isRequestLoggerEnabled())

 		{

 			if (requestLogger == null)

 			{

 				requestLogger = newRequestLogger();

 			}

 		}

 		else

 		{

 			requestLogger = null;

 		}

 		return requestLogger;

 	}

	

 	public IRequestLoggerSettings getRequestLoggerSettings()

 	{

 		return getSettings();

 	}

	

 	public IResourceSettings getResourceSettings()

 	{

 		return getSettings();

 	}

	

 	public ISecuritySettings getSecuritySettings()

 	{

 		return getSettings();

 	}

	

 	public ISessionSettings getSessionSettings()

 	{

 		return getSettings();

 	}

	

 	public final ISessionStore getSessionStore()

 	{

 		return sessionStore;

 	}

	

 	public final SharedResources getSharedResources()

 	{

 		return sharedResources;

 	}

	

 	public final void initializeComponents()

 	{

 		// Load any wicket properties files we can find

 		try

 		{

 			// Load properties files used by all libraries

 			final Enumeration resources = Thread.currentThread()

 				.getContextClassLoader()

 				.getResources("wicket.properties");

 			while (resources.hasMoreElements())

 			{

 				InputStream in = null;

 				try

 				{

 					final URL url = (URL)resources.nextElement();

 					final Properties properties = new Properties();

 					in = url.openStream();

 					properties.load(in);

 					load(properties);

 				}

 				finally

 				{

 					if (in != null)

 					{

 						in.close();

 					}

 				}

 			}

 		}

 		catch (IOException e)

 		{

 			throw new WicketRuntimeException("Unable to load initializers file", e);

 		}

 		// now call any initializers we read

 		callInitializers();

 	}

	

 	public void logEventTarget(IRequestTarget target)

 	{

 	}

	

 	public void logResponseTarget(IRequestTarget requestTarget)

 	{

 	}

	

 	public abstract RequestCycle newRequestCycle(final Request request, final Response response);

	

 	public final RequestCycle newRequestCycle(Application application, Request request,

 		Response response)

 	{

 		throw new UnsupportedOperationException();

 	}

	

 	public abstract Session newSession(Request request, Response response);

	

 	public final void removeComponentInstantiationListener(

 		final IComponentInstantiationListener listener)

 	{

 		final IComponentInstantiationListener[] listeners = componentInstantiationListeners;

 		final int len = listeners.length;

 		if (listener != null && len > 0)

 		{

 			int pos = 0;

 			for (pos = 0; pos < len; pos++)

 			{

 				if (listener == listeners[pos])

 				{

 					break;

 				}

 			}

 			if (pos < len)

 			{

 				listeners[pos] = listeners[len - 1];

 				final IComponentInstantiationListener[] newListeners = new IComponentInstantiationListener[len - 1];

 				System.arraycopy(listeners, 0, newListeners, 0, newListeners.length);

 				componentInstantiationListeners = newListeners;

 			}

 		}

 	}

	

 	// TODO: Replace the Serializable type with Object for next wicket version

 	public final synchronized void setMetaData(final MetaDataKey key, final Serializable object)

 	{

 		metaData = key.set(metaData, object);

 	}

	

 	private final void addInitializer(String className)

 	{

 		IInitializer initializer = (IInitializer)Objects.newInstance(className);

 		if (initializer != null)

 		{

 			initializers.add(initializer);

 		}

 	}

	

 	private final void callDestroyers()

 	{

 		for (Iterator i = initializers.iterator(); i.hasNext();)

 		{

 			IInitializer initializer = (IInitializer)i.next();

 			if (initializer instanceof IDestroyer)

 			{

 				log.info("[" + getName() + "] destroy: " + initializer);

 				((IDestroyer)initializer).destroy(this);

 			}

 		}

 	}

	

 	private final void callInitializers()

 	{

 		for (Iterator i = initializers.iterator(); i.hasNext();)

 		{

 			IInitializer initializer = (IInitializer)i.next();

 			log.info("[" + getName() + "] init: " + initializer);

 			initializer.init(this);

 		}

 	}

	

 	private Settings getSettings()

 	{

 		if (!settingsAccessible)

 		{

 			throw new WicketRuntimeException(

 				"Use Application.init() method for configuring your application object");

 		}

 		if (settings == null)

 		{

 			settings = new Settings(this);

 		}

 		return settings;

 	}

	

 	private final void load(final Properties properties)

 	{

 		addInitializer(properties.getProperty("initializer"));

 		addInitializer(properties.getProperty(getName() + "-initializer"));

 	}

	

 	// TODO remove after deprecation release

 	protected final void destroy()

 	{

 	}

	

 	protected void onDestroy()

 	{

 	}

	

 	// TODO remove after deprecation release

 	protected final Object getRequestCycleFactory()

 	{

 		throw new UnsupportedOperationException();

 	}

	

 	// TODO remove after deprecation release

 	protected final Object getSessionFactory()

 	{

 		throw new UnsupportedOperationException();

 	}

	

 	protected void init()

 	{

 	}

	

 	protected void internalDestroy()

 	{

 		// Clear caches of Class keys so the classloader can be garbage

 		// collected (WICKET-625)

 		PropertyResolver.destroy(this);

 		getMarkupSettings().getMarkupCache().shutdown();

 		onDestroy();

 		callDestroyers();

 		applicationKeyToApplication.remove(getApplicationKey());

 		Session.unset();

 		RequestContext.unset();

 		RequestCycle.set(null);

 	}

	

 	protected void internalInit()

 	{

 		settingsAccessible = true;

 		IPageSettings pageSettings = getPageSettings();

 		// Install default component resolvers

 		pageSettings.addComponentResolver(new ParentResolver());

 		pageSettings.addComponentResolver(new AutoComponentResolver());

 		pageSettings.addComponentResolver(new MarkupInheritanceResolver());

 		pageSettings.addComponentResolver(new HtmlHeaderResolver());

 		pageSettings.addComponentResolver(new WicketLinkResolver());

 		pageSettings.addComponentResolver(new WicketMessageResolver());

 		pageSettings.addComponentResolver(new WicketMessageTagHandler());

 		pageSettings.addComponentResolver(new FragmentResolver());

 		pageSettings.addComponentResolver(new RelativePathPrefixHandler());

 		pageSettings.addComponentResolver(new EnclosureResolver());