/*
 * Copyright (C) 2007-2012 Argeo GmbH
 *
 * Licensed 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.argeo.jcr;

import java.io.InputStream;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.jcr.Binary;
import javax.jcr.Credentials;
import javax.jcr.LoginException;
import javax.jcr.NoSuchWorkspaceException;
import javax.jcr.PropertyType;
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.Value;
import javax.jcr.ValueFormatException;

/**
 * Wrapper around a JCR repository which allows to simplify configuration and
 * intercept some actions. It exposes itself as a {@link Repository}.
 */
public abstract class JcrRepositoryWrapper implements Repository {
	// private final static Log log = LogFactory
	// .getLog(JcrRepositoryWrapper.class);

	// wrapped repository
	private Repository repository;

	private Map<String, String> additionalDescriptors = new HashMap<>();

	private Boolean autocreateWorkspaces = false;

	public JcrRepositoryWrapper(Repository repository) {
		setRepository(repository);
	}

	/**
	 * Empty constructor
	 */
	public JcrRepositoryWrapper() {
	}

	// /** Initializes */
	// public void init() {
	// }
	//
	// /** Shutdown the repository */
	// public void destroy() throws Exception {
	// }

	protected void putDescriptor(String key, String value) {
		if (Arrays.asList(getRepository().getDescriptorKeys()).contains(key))
			throw new IllegalArgumentException("Descriptor key " + key + " is already defined in wrapped repository");
		if (value == null)
			additionalDescriptors.remove(key);
		else
			additionalDescriptors.put(key, value);
	}

	/*
	 * DELEGATED JCR REPOSITORY METHODS
	 */

	public String getDescriptor(String key) {
		if (additionalDescriptors.containsKey(key))
			return additionalDescriptors.get(key);
		return getRepository().getDescriptor(key);
	}

	public String[] getDescriptorKeys() {
		if (additionalDescriptors.size() == 0)
			return getRepository().getDescriptorKeys();
		List<String> keys = Arrays.asList(getRepository().getDescriptorKeys());
		keys.addAll(additionalDescriptors.keySet());
		return keys.toArray(new String[keys.size()]);
	}

	/** Central login method */
	public Session login(Credentials credentials, String workspaceName)
			throws LoginException, NoSuchWorkspaceException, RepositoryException {
		Session session;
		try {
			session = getRepository().login(credentials, workspaceName);
		} catch (NoSuchWorkspaceException e) {
			if (autocreateWorkspaces && workspaceName != null)
				session = createWorkspaceAndLogsIn(credentials, workspaceName);
			else
				throw e;
		}
		processNewSession(session, workspaceName);
		return session;
	}

	public Session login() throws LoginException, RepositoryException {
		return login(null, null);
	}

	public Session login(Credentials credentials) throws LoginException, RepositoryException {
		return login(credentials, null);
	}

	public Session login(String workspaceName) throws LoginException, NoSuchWorkspaceException, RepositoryException {
		return login(null, workspaceName);
	}

	/** Called after a session has been created, does nothing by default. */
	protected void processNewSession(Session session, String workspaceName) {
	}

	/** Wraps access to the repository, making sure it is available. */
	protected synchronized Repository getRepository() {
		// if (repository == null) {
		// throw new ArgeoJcrException("No repository initialized."
		// + " Was the init() method called?"
		// + " The destroy() method should also"
		// + " be called on shutdown.");
		// }
		return repository;
	}

	/**
	 * Logs in to the default workspace, creates the required workspace, logs out,
	 * logs in to the required workspace.
	 */
	protected Session createWorkspaceAndLogsIn(Credentials credentials, String workspaceName)
			throws RepositoryException {
		if (workspaceName == null)
			throw new ArgeoJcrException("No workspace specified.");
		Session session = getRepository().login(credentials);
		session.getWorkspace().createWorkspace(workspaceName);
		session.logout();
		return getRepository().login(credentials, workspaceName);
	}

	public boolean isStandardDescriptor(String key) {
		return getRepository().isStandardDescriptor(key);
	}

	public boolean isSingleValueDescriptor(String key) {
		if (additionalDescriptors.containsKey(key))
			return true;
		return getRepository().isSingleValueDescriptor(key);
	}

	public Value getDescriptorValue(String key) {
		if (additionalDescriptors.containsKey(key))
			return new StrValue(additionalDescriptors.get(key));
		return getRepository().getDescriptorValue(key);
	}

	public Value[] getDescriptorValues(String key) {
		return getRepository().getDescriptorValues(key);
	}

	public synchronized void setRepository(Repository repository) {
		this.repository = repository;
	}

	public void setAutocreateWorkspaces(Boolean autocreateWorkspaces) {
		this.autocreateWorkspaces = autocreateWorkspaces;
	}

	protected static class StrValue implements Value {
		private final String str;

		public StrValue(String str) {
			this.str = str;
		}

		@Override
		public String getString() throws ValueFormatException, IllegalStateException, RepositoryException {
			return str;
		}

		@Override
		public InputStream getStream() throws RepositoryException {
			throw new UnsupportedOperationException();
		}

		@Override
		public Binary getBinary() throws RepositoryException {
			throw new UnsupportedOperationException();
		}

		@Override
		public long getLong() throws ValueFormatException, RepositoryException {
			try {
				return Long.parseLong(str);
			} catch (NumberFormatException e) {
				throw new ValueFormatException("Cannot convert", e);
			}
		}

		@Override
		public double getDouble() throws ValueFormatException, RepositoryException {
			try {
				return Double.parseDouble(str);
			} catch (NumberFormatException e) {
				throw new ValueFormatException("Cannot convert", e);
			}
		}

		@Override
		public BigDecimal getDecimal() throws ValueFormatException, RepositoryException {
			try {
				return new BigDecimal(str);
			} catch (NumberFormatException e) {
				throw new ValueFormatException("Cannot convert", e);
			}
		}

		@Override
		public Calendar getDate() throws ValueFormatException, RepositoryException {
			throw new UnsupportedOperationException();
		}

		@Override
		public boolean getBoolean() throws ValueFormatException, RepositoryException {
			try {
				return Boolean.parseBoolean(str);
			} catch (NumberFormatException e) {
				throw new ValueFormatException("Cannot convert", e);
			}
		}

		@Override
		public int getType() {
			return PropertyType.STRING;
		}

	}

}