/*
 * 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.pageStore;

import java.io.Serializable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionBindingListener;

import org.apache.wicket.Session;
import org.apache.wicket.page.IManageablePage;
import org.apache.wicket.util.lang.Args;
import org.apache.wicket.util.lang.Bytes;
import org.apache.wicket.util.lang.Classes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Abstract base class for stores that keep an identifier in the session only, while holding the actual pages
 * in a secondary persistent storage.
 * 
 * @see #getSessionIdentifier(IPageContext, boolean)
 */
public abstract class AbstractPersistentPageStore implements IPageStore
{
	private static final String KEY_PREFIX = "wicket:";

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

	/**
	 * A cache holding all store, the key is the application name suffixed with the page store implementation class.
	 */
	private static final ConcurrentMap<String, AbstractPersistentPageStore> STORES = new ConcurrentHashMap<>();

	private static final ThreadLocal<Boolean> gettingSessionAttribute = new ThreadLocal<>()
	{
		protected Boolean initialValue()
		{
			return Boolean.FALSE;
		}
	};

	private final String storeKey;

	protected AbstractPersistentPageStore(String applicationName)
	{
		this.storeKey = Args.notNull(applicationName, "applicationName") + ":" + getClass().getSimpleName();

		if (STORES.containsKey(storeKey))
		{
			throw new IllegalStateException(
				"Store with key '" + storeKey + "' already exists.");
		}
		STORES.put(storeKey, this);
	}

	@Override
	public void destroy()
	{
		STORES.remove(storeKey);
	}

	@Override
	public boolean canBeAsynchronous(IPageContext context)
	{
		// session attribute must be added here *before* any asynchronous calls
		// when session is no longer available
		getSessionIdentifier(context, true);

		return true;
	}

	@Override
	public IManageablePage getPage(IPageContext context, int id)
	{
		String sessionIdentifier = getSessionIdentifier(context, false);
		if (sessionIdentifier == null)
		{
			return null;
		}

		return getPersistedPage(sessionIdentifier, id);
	}

	protected abstract IManageablePage getPersistedPage(String sessionIdentifier, int id);
	
	@Override
	public void removePage(IPageContext context, IManageablePage page)
	{
		String sessionIdentifier = getSessionIdentifier(context, false);
		if (sessionIdentifier == null)
		{
			return;
		}
		
		removePersistedPage(sessionIdentifier, page);
	}

	protected abstract void removePersistedPage(String sessionIdentifier, IManageablePage page);

	@Override
	public void removeAllPages(IPageContext context)
	{
		String sessionIdentifier = getSessionIdentifier(context, false);
		if (sessionIdentifier == null)
		{
			return;
		}
		
		removeAllPersistedPages(sessionIdentifier);
	}

	protected abstract void removeAllPersistedPages(String sessionIdentifier);

	@Override
	public void addPage(IPageContext context, IManageablePage page)
	{
		String sessionIdentifier = getSessionIdentifier(context, true);
		
		addPersistedPage(sessionIdentifier, page);
	}

	/**
	 * Add a page.
	 * 
	 * @param sessionIdentifier identifier of session
	 * @param page page to add
	 */
	protected abstract void addPersistedPage(String sessionIdentifier, IManageablePage page);

	/**
	 * Get the distinct and stable identifier for the given context.
	 * 
	 * @param context the context to identify
	 * @param create should a new identifier be created if not there already
	 */
	private String getSessionIdentifier(IPageContext context, boolean create)
	{
		gettingSessionAttribute.set(Boolean.TRUE);
		try {
			String key = KEY_PREFIX + Classes.simpleName(getClass());
			
			SessionAttribute attribute = context.getSessionAttribute(key, create ? () -> {
				return new SessionAttribute(storeKey, createSessionIdentifier(context));
			} : null);
			
			if (attribute == null)
			{
				return null;
			}
			return attribute.sessionIdentifier;
		} finally {
			gettingSessionAttribute.set(Boolean.FALSE);
		}
	}

	/**
	 * Create an identifier for the given context.
	 * <p>
	 * Default implementation uses {@link IPageContext#getSessionId(boolean)}}.
	 * 
	 * @param context context
	 * @return identifier for the session
	 */
	protected String createSessionIdentifier(IPageContext context)
	{
		return context.getSessionId(true);
	}

	/**
	 * Attribute held in session.
	 */
	private static class SessionAttribute implements Serializable, HttpSessionBindingListener
	{

		private final String storeKey;

		/**
		 * The identifier of the session, may not be equal to {@link Session#getId()}, e.g. when
		 * the container changes the id after authorization.
		 */
		public final String sessionIdentifier;

		public SessionAttribute(String storeKey, String sessionIdentifier)
		{
			this.storeKey = Args.notNull(storeKey, "storeKey");
			this.sessionIdentifier = Args.notNull(sessionIdentifier, "sessionIdentifier");
		}


		@Override
		public void valueBound(HttpSessionBindingEvent event)
		{
		}

		@Override
		public void valueUnbound(HttpSessionBindingEvent event)
		{
			AbstractPersistentPageStore store = STORES.get(storeKey);
			if (store == null)
			{
				log.warn(
					"Cannot remove data '{}' because disk store '{}' is no longer present.", sessionIdentifier, storeKey);
			}
			else
			{
				if (Boolean.FALSE.equals(gettingSessionAttribute.get()))
				{
					store.removeAllPersistedPages(sessionIdentifier);
				}		
			}
		}
	}

	public String getSessionIdentifier(IPageContext context)
	{
		return getSessionIdentifier(context, true);
	}

	protected static class PersistedPage implements IPersistedPage
	{
		private final int pageId;

		private final String pageType;

		private final long pageSize;

		public PersistedPage(int pageId, String pageType, long pageSize)
		{
			this.pageId = pageId;
			this.pageType = pageType;
			this.pageSize = pageSize;
		}

		@Override
		public int getPageId()
		{
			return pageId;
		}

		@Override
		public Bytes getPageSize()
		{
			return Bytes.bytes(pageSize);
		}

		@Override
		public String getPageType()
		{
			return pageType;
		}

	}
}
