/*
 * 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.sling.discovery.impl.setup;

import java.util.Calendar;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import javax.jcr.Node;
import javax.jcr.PathNotFoundException;
import javax.jcr.Property;
import javax.jcr.PropertyIterator;
import javax.jcr.PropertyType;
import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.apache.sling.api.resource.ModifiableValueMap;
import org.apache.sling.api.resource.SyntheticResource;
import org.apache.sling.api.resource.ValueMap;
import org.apache.sling.api.wrappers.ValueMapDecorator;

// TODO this should come from a commons module, for now
// it's duplicated from the discovery module
public class MockedResource extends SyntheticResource {

	private final MockedResourceResolver mockedResourceResolver;
	private Session session;

	public MockedResource(MockedResourceResolver resourceResolver, String path,
			String resourceType) {
		super(resourceResolver, path, resourceType);
		mockedResourceResolver = resourceResolver;

		resourceResolver.register(this);
	}

	private Session getSession() {
		synchronized (this) {
			if (session == null) {
				try {
					session = mockedResourceResolver.getSession();
				} catch (RepositoryException e) {
					throw new RuntimeException("RepositoryException: " + e, e);
				}
			}
			return session;
		}
	}

	@Override
	protected void finalize() throws Throwable {
		close();
		super.finalize();
	}

	public void close() {
		synchronized (this) {
			if (session != null) {
				if (session.isLive()) {
					session.logout();
				}
				session = null;
			}
		}
	}

	@SuppressWarnings("unchecked")
	@Override
	public <AdapterType> AdapterType adaptTo(Class<AdapterType> type) {
		if (type.equals(Node.class)) {
			try {
				return (AdapterType) getSession().getNode(getPath());
			} catch (Exception e) {
				throw new RuntimeException("Exception occurred: " + e, e);
			}
		} else if (type.equals(ValueMap.class)) {
			try {
				Session session = getSession();
				Node node = session.getNode(getPath());
				HashMap<String, Object> map = new HashMap<String, Object>();

				PropertyIterator properties = node.getProperties();
				while (properties.hasNext()) {
					Property p = properties.nextProperty();
					if (p.getType() == PropertyType.BOOLEAN) {
						map.put(p.getName(), p.getBoolean());
					} else if (p.getType() == PropertyType.STRING) {
						map.put(p.getName(), p.getString());
					} else if (p.getType() == PropertyType.DATE) {
						map.put(p.getName(), p.getDate().getTime());
					} else if (p.getType() == PropertyType.NAME) {
						map.put(p.getName(), p.getName());
					} else {
						throw new RuntimeException(
								"Unsupported property type: " + p.getType());
					}
				}
				ValueMap valueMap = new ValueMapDecorator(map);
				return (AdapterType) valueMap;
			} catch (Exception e) {
				e.printStackTrace();
				return null;
			}
		} else if (type.equals(ModifiableValueMap.class)) {
			return (AdapterType) new ModifiableValueMap() {

				public Collection<Object> values() {
					throw new UnsupportedOperationException();
				}

				public int size() {
					throw new UnsupportedOperationException();
				}

				public Object remove(Object arg0) {
					Session session = getSession();
					try{
						final Node node = session.getNode(getPath());
						final Property p = node.getProperty(String.valueOf(arg0));
						if (p!=null) {
							p.remove();
						}
						// this is not according to the spec - but OK for tests since
						// the return value is never used
								return null;
					} catch(PathNotFoundException pnfe) {
						// perfectly fine
						return null;
					} catch(RepositoryException e) {
						throw new RuntimeException(e);
					}
				}

				public void putAll(Map<? extends String, ? extends Object> arg0) {
					throw new UnsupportedOperationException();
				}

				public Object put(String arg0, Object arg1) {
					Session session = getSession();
					try{
						final Node node = session.getNode(getPath());
						Object result = null;
						if (node.hasProperty(arg0)) {
							final Property previous = node.getProperty(arg0);
							if (previous==null) {
								// null
							} else if (previous.getType() == PropertyType.STRING) {
								result = previous.getString();
							} else if (previous.getType() == PropertyType.DATE) {
								result = previous.getDate();
							} else if (previous.getType() == PropertyType.BOOLEAN) {
								result = previous.getBoolean();
							} else {
								throw new UnsupportedOperationException();
							}
						}
						if (arg1 instanceof String) {
							node.setProperty(arg0, (String)arg1);
						} else if (arg1 instanceof Long) {
							node.setProperty(arg0, (Long)arg1);
						} else if (arg1 instanceof Calendar) {
							node.setProperty(arg0, (Calendar)arg1);
						} else if (arg1 instanceof Boolean) {
							node.setProperty(arg0, (Boolean)arg1);
						} else {
							throw new UnsupportedOperationException();
						}
						return result;
					} catch(RepositoryException e) {
						throw new RuntimeException(e);
					}
				}

				public Set<String> keySet() {
					Session session = getSession();
					try {
						final Node node = session.getNode(getPath());
						final PropertyIterator pi = node.getProperties();
						final Set<String> result = new HashSet<String>();
						while(pi.hasNext()) {
							final Property p = pi.nextProperty();
							result.add(p.getName());
						}
						return result;
					} catch (RepositoryException e) {
						throw new RuntimeException(e);
					}
				}

				public boolean isEmpty() {
					throw new UnsupportedOperationException();
				}

				public Object get(Object arg0) {
					try {
						Node node = session.getNode(getPath());
						return node.getProperty(String.valueOf(arg0));
					} catch (PathNotFoundException e) {
						return null;
					} catch (RepositoryException e) {
						e.printStackTrace();
						throw new RuntimeException();
					}
					// throw new UnsupportedOperationException();
				}

				public Set<Entry<String, Object>> entrySet() {
					throw new UnsupportedOperationException();
				}

				public boolean containsValue(Object arg0) {
					throw new UnsupportedOperationException();
				}

				public boolean containsKey(Object arg0) {
					Session session = getSession();
					try{
						final Node node = session.getNode(getPath());
						return node.hasProperty(String.valueOf(arg0));
					} catch(RepositoryException re) {
						throw new RuntimeException(re);
					}
				}

				public void clear() {
					throw new UnsupportedOperationException();
				}

				public <T> T get(String name, T defaultValue) {
					throw new UnsupportedOperationException();
				}

				public <T> T get(String name, Class<T> type) {
					Session session = getSession();
					try{
						final Node node = session.getNode(getPath());
						if (node==null) {
							return null;
						}
						Property p = node.getProperty(name);
						if (p==null) {
							return null;
						}
						if (type.equals(Calendar.class)) {
							return (T) p.getDate();
						} else if (type.equals(String.class)) {
							return (T) p.getString();
						} else {
							throw new UnsupportedOperationException();
						}
					} catch(RepositoryException e) {
						throw new RuntimeException(e);
					}
				}
			};
		} else {
			return super.adaptTo(type);
		}
	}

}